@types/babel-types

  • Version 7.0.11
  • Published
  • 114 kB
  • No dependencies
  • MIT license

Install

npm i @types/babel-types
yarn add @types/babel-types
pnpm add @types/babel-types

Overview

TypeScript definitions for babel-types

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable react

const react: ReactHelpers;

    Functions

    function anyTypeAnnotation

    anyTypeAnnotation: () => AnyTypeAnnotation;

      function arrayExpression

      arrayExpression: (
      elements?: Array<null | Expression | SpreadElement>
      ) => ArrayExpression;

        function arrayPattern

        arrayPattern: (
        elements?: Expression[],
        typeAnnotation?: TypeAnnotation
        ) => ArrayPattern;

          function arrayTypeAnnotation

          arrayTypeAnnotation: (elementType?: FlowTypeAnnotation) => ArrayTypeAnnotation;

            function arrowFunctionExpression

            arrowFunctionExpression: (
            params?: LVal[],
            body?: BlockStatement | Expression,
            async?: boolean
            ) => ArrowFunctionExpression;

              function assertAnyTypeAnnotation

              assertAnyTypeAnnotation: (
              node: object | null | undefined,
              opts?: object
              ) => asserts node is AnyTypeAnnotation;

                function assertArrayExpression

                assertArrayExpression: (
                node: object | null | undefined,
                opts?: object
                ) => asserts node is ArrayExpression;

                  function assertArrayPattern

                  assertArrayPattern: (
                  node: object | null | undefined,
                  opts?: object
                  ) => asserts node is ArrayPattern;

                    function assertArrayTypeAnnotation

                    assertArrayTypeAnnotation: (
                    node: object | null | undefined,
                    opts?: object
                    ) => asserts node is ArrayTypeAnnotation;

                      function assertArrowFunctionExpression

                      assertArrowFunctionExpression: (
                      node: object | null | undefined,
                      opts?: object
                      ) => asserts node is ArrowFunctionExpression;

                        function assertAssignmentExpression

                        assertAssignmentExpression: (
                        node: object | null | undefined,
                        opts?: object
                        ) => asserts node is AssignmentExpression;

                          function assertAssignmentPattern

                          assertAssignmentPattern: (
                          node: object | null | undefined,
                          opts?: object
                          ) => asserts node is AssignmentPattern;

                            function assertAwaitExpression

                            assertAwaitExpression: (
                            node: object | null | undefined,
                            opts?: object
                            ) => asserts node is AwaitExpression;

                              function assertBinary

                              assertBinary: (
                              node: object | null | undefined,
                              opts?: object
                              ) => asserts node is Binary;

                                function assertBinaryExpression

                                assertBinaryExpression: (
                                node: object | null | undefined,
                                opts?: object
                                ) => asserts node is BinaryExpression;

                                  function assertBindExpression

                                  assertBindExpression: (
                                  node: object | null | undefined,
                                  opts?: object
                                  ) => asserts node is BindExpression;

                                    function assertBlock

                                    assertBlock: (
                                    node: object | null | undefined,
                                    opts?: object
                                    ) => asserts node is Block;

                                      function assertBlockParent

                                      assertBlockParent: (
                                      node: object | null | undefined,
                                      opts?: object
                                      ) => asserts node is BlockParent;

                                        function assertBlockStatement

                                        assertBlockStatement: (
                                        node: object | null | undefined,
                                        opts?: object
                                        ) => asserts node is BlockStatement;

                                          function assertBooleanLiteral

                                          assertBooleanLiteral: (
                                          node: object | null | undefined,
                                          opts?: object
                                          ) => asserts node is BooleanLiteral;

                                            function assertBooleanLiteralTypeAnnotation

                                            assertBooleanLiteralTypeAnnotation: (
                                            node: object | null | undefined,
                                            opts?: object
                                            ) => asserts node is BooleanLiteralTypeAnnotation;

                                              function assertBooleanTypeAnnotation

                                              assertBooleanTypeAnnotation: (
                                              node: object | null | undefined,
                                              opts?: object
                                              ) => asserts node is BooleanTypeAnnotation;

                                                function assertBreakStatement

                                                assertBreakStatement: (
                                                node: object | null | undefined,
                                                opts?: object
                                                ) => asserts node is BreakStatement;

                                                  function assertCallExpression

                                                  assertCallExpression: (
                                                  node: object | null | undefined,
                                                  opts?: object
                                                  ) => asserts node is CallExpression;

                                                    function assertCatchClause

                                                    assertCatchClause: (
                                                    node: object | null | undefined,
                                                    opts?: object
                                                    ) => asserts node is CatchClause;

                                                      function assertClass

                                                      assertClass: (
                                                      node: object | null | undefined,
                                                      opts?: object
                                                      ) => asserts node is Class;

                                                        function assertClassBody

                                                        assertClassBody: (
                                                        node: object | null | undefined,
                                                        opts?: object
                                                        ) => asserts node is ClassBody;

                                                          function assertClassDeclaration

                                                          assertClassDeclaration: (
                                                          node: object | null | undefined,
                                                          opts?: object
                                                          ) => asserts node is ClassDeclaration;

                                                            function assertClassExpression

                                                            assertClassExpression: (
                                                            node: object | null | undefined,
                                                            opts?: object
                                                            ) => asserts node is ClassExpression;

                                                              function assertClassImplements

                                                              assertClassImplements: (
                                                              node: object | null | undefined,
                                                              opts?: object
                                                              ) => asserts node is ClassImplements;

                                                                function assertClassMethod

                                                                assertClassMethod: (
                                                                node: object | null | undefined,
                                                                opts?: object
                                                                ) => asserts node is ClassMethod;

                                                                  function assertClassProperty

                                                                  assertClassProperty: (
                                                                  node: object | null | undefined,
                                                                  opts?: object
                                                                  ) => asserts node is ClassProperty;

                                                                    function assertCompletionStatement

                                                                    assertCompletionStatement: (
                                                                    node: object | null | undefined,
                                                                    opts?: object
                                                                    ) => asserts node is CompletionStatement;

                                                                      function assertConditional

                                                                      assertConditional: (
                                                                      node: object | null | undefined,
                                                                      opts?: object
                                                                      ) => asserts node is Conditional;

                                                                        function assertConditionalExpression

                                                                        assertConditionalExpression: (
                                                                        node: object | null | undefined,
                                                                        opts?: object
                                                                        ) => asserts node is ConditionalExpression;

                                                                          function assertContinueStatement

                                                                          assertContinueStatement: (
                                                                          node: object | null | undefined,
                                                                          opts?: object
                                                                          ) => asserts node is ContinueStatement;

                                                                            function assertDebuggerStatement

                                                                            assertDebuggerStatement: (
                                                                            node: object | null | undefined,
                                                                            opts?: object
                                                                            ) => asserts node is DebuggerStatement;

                                                                              function assertDeclaration

                                                                              assertDeclaration: (
                                                                              node: object | null | undefined,
                                                                              opts?: object
                                                                              ) => asserts node is Declaration;

                                                                                function assertDeclareClass

                                                                                assertDeclareClass: (
                                                                                node: object | null | undefined,
                                                                                opts?: object
                                                                                ) => asserts node is DeclareClass;

                                                                                  function assertDeclareFunction

                                                                                  assertDeclareFunction: (
                                                                                  node: object | null | undefined,
                                                                                  opts?: object
                                                                                  ) => asserts node is DeclareFunction;

                                                                                    function assertDeclareInterface

                                                                                    assertDeclareInterface: (
                                                                                    node: object | null | undefined,
                                                                                    opts?: object
                                                                                    ) => asserts node is DeclareInterface;

                                                                                      function assertDeclareModule

                                                                                      assertDeclareModule: (
                                                                                      node: object | null | undefined,
                                                                                      opts?: object
                                                                                      ) => asserts node is DeclareModule;

                                                                                        function assertDeclareTypeAlias

                                                                                        assertDeclareTypeAlias: (
                                                                                        node: object | null | undefined,
                                                                                        opts?: object
                                                                                        ) => asserts node is DeclareTypeAlias;

                                                                                          function assertDeclareVariable

                                                                                          assertDeclareVariable: (
                                                                                          node: object | null | undefined,
                                                                                          opts?: object
                                                                                          ) => asserts node is DeclareVariable;

                                                                                            function assertDecorator

                                                                                            assertDecorator: (
                                                                                            node: object | null | undefined,
                                                                                            opts?: object
                                                                                            ) => asserts node is Decorator;

                                                                                              function assertDirective

                                                                                              assertDirective: (
                                                                                              node: object | null | undefined,
                                                                                              opts?: object
                                                                                              ) => asserts node is Directive;

                                                                                                function assertDirectiveLiteral

                                                                                                assertDirectiveLiteral: (
                                                                                                node: object | null | undefined,
                                                                                                opts?: object
                                                                                                ) => asserts node is DirectiveLiteral;

                                                                                                  function assertDoExpression

                                                                                                  assertDoExpression: (
                                                                                                  node: object | null | undefined,
                                                                                                  opts?: object
                                                                                                  ) => asserts node is DoExpression;

                                                                                                    function assertDoWhileStatement

                                                                                                    assertDoWhileStatement: (
                                                                                                    node: object | null | undefined,
                                                                                                    opts?: object
                                                                                                    ) => asserts node is DoWhileStatement;

                                                                                                      function assertEmptyStatement

                                                                                                      assertEmptyStatement: (
                                                                                                      node: object | null | undefined,
                                                                                                      opts?: object
                                                                                                      ) => asserts node is EmptyStatement;

                                                                                                        function assertExistentialTypeParam

                                                                                                        assertExistentialTypeParam: (
                                                                                                        node: object | null | undefined,
                                                                                                        opts?: object
                                                                                                        ) => asserts node is ExistentialTypeParam;

                                                                                                          function assertExportAllDeclaration

                                                                                                          assertExportAllDeclaration: (
                                                                                                          node: object | null | undefined,
                                                                                                          opts?: object
                                                                                                          ) => asserts node is ExportAllDeclaration;

                                                                                                            function assertExportDeclaration

                                                                                                            assertExportDeclaration: (
                                                                                                            node: object | null | undefined,
                                                                                                            opts?: object
                                                                                                            ) => asserts node is ExportDeclaration;

                                                                                                              function assertExportDefaultDeclaration

                                                                                                              assertExportDefaultDeclaration: (
                                                                                                              node: object | null | undefined,
                                                                                                              opts?: object
                                                                                                              ) => asserts node is ExportDefaultDeclaration;

                                                                                                                function assertExportDefaultSpecifier

                                                                                                                assertExportDefaultSpecifier: (
                                                                                                                node: object | null | undefined,
                                                                                                                opts?: object
                                                                                                                ) => asserts node is ExportDefaultSpecifier;

                                                                                                                  function assertExportNamedDeclaration

                                                                                                                  assertExportNamedDeclaration: (
                                                                                                                  node: object | null | undefined,
                                                                                                                  opts?: object
                                                                                                                  ) => asserts node is ExportNamedDeclaration;

                                                                                                                    function assertExportNamespaceSpecifier

                                                                                                                    assertExportNamespaceSpecifier: (
                                                                                                                    node: object | null | undefined,
                                                                                                                    opts?: object
                                                                                                                    ) => asserts node is ExportNamespaceSpecifier;

                                                                                                                      function assertExportSpecifier

                                                                                                                      assertExportSpecifier: (
                                                                                                                      node: object | null | undefined,
                                                                                                                      opts?: object
                                                                                                                      ) => asserts node is ExportSpecifier;

                                                                                                                        function assertExpression

                                                                                                                        assertExpression: (
                                                                                                                        node: object | null | undefined,
                                                                                                                        opts?: object
                                                                                                                        ) => asserts node is Expression;

                                                                                                                          function assertExpressionStatement

                                                                                                                          assertExpressionStatement: (
                                                                                                                          node: object | null | undefined,
                                                                                                                          opts?: object
                                                                                                                          ) => asserts node is ExpressionStatement;

                                                                                                                            function assertExpressionWrapper

                                                                                                                            assertExpressionWrapper: (
                                                                                                                            node: object | null | undefined,
                                                                                                                            opts?: object
                                                                                                                            ) => asserts node is ExpressionWrapper;

                                                                                                                              function assertFile

                                                                                                                              assertFile: (
                                                                                                                              node: object | null | undefined,
                                                                                                                              opts?: object
                                                                                                                              ) => asserts node is File;

                                                                                                                                function assertFlow

                                                                                                                                assertFlow: (
                                                                                                                                node: object | null | undefined,
                                                                                                                                opts?: object
                                                                                                                                ) => asserts node is Flow;

                                                                                                                                  function assertFlowBaseAnnotation

                                                                                                                                  assertFlowBaseAnnotation: (
                                                                                                                                  node: object | null | undefined,
                                                                                                                                  opts?: object
                                                                                                                                  ) => asserts node is FlowBaseAnnotation;

                                                                                                                                    function assertFlowDeclaration

                                                                                                                                    assertFlowDeclaration: (
                                                                                                                                    node: object | null | undefined,
                                                                                                                                    opts?: object
                                                                                                                                    ) => asserts node is FlowDeclaration;

                                                                                                                                      function assertFor

                                                                                                                                      assertFor: (
                                                                                                                                      node: object | null | undefined,
                                                                                                                                      opts?: object
                                                                                                                                      ) => asserts node is For;

                                                                                                                                        function assertForInStatement

                                                                                                                                        assertForInStatement: (
                                                                                                                                        node: object | null | undefined,
                                                                                                                                        opts?: object
                                                                                                                                        ) => asserts node is ForInStatement;

                                                                                                                                          function assertForOfStatement

                                                                                                                                          assertForOfStatement: (
                                                                                                                                          node: object | null | undefined,
                                                                                                                                          opts?: object
                                                                                                                                          ) => asserts node is ForOfStatement;

                                                                                                                                            function assertForStatement

                                                                                                                                            assertForStatement: (
                                                                                                                                            node: object | null | undefined,
                                                                                                                                            opts?: object
                                                                                                                                            ) => asserts node is ForStatement;

                                                                                                                                              function assertForXStatement

                                                                                                                                              assertForXStatement: (
                                                                                                                                              node: object | null | undefined,
                                                                                                                                              opts?: object
                                                                                                                                              ) => asserts node is ForXStatement;

                                                                                                                                                function assertFunction

                                                                                                                                                assertFunction: (
                                                                                                                                                node: object | null | undefined,
                                                                                                                                                opts?: object
                                                                                                                                                ) => asserts node is Function;

                                                                                                                                                  function assertFunctionDeclaration

                                                                                                                                                  assertFunctionDeclaration: (
                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                  opts?: object
                                                                                                                                                  ) => asserts node is FunctionDeclaration;

                                                                                                                                                    function assertFunctionExpression

                                                                                                                                                    assertFunctionExpression: (
                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                    opts?: object
                                                                                                                                                    ) => asserts node is FunctionExpression;

                                                                                                                                                      function assertFunctionParent

                                                                                                                                                      assertFunctionParent: (
                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                      opts?: object
                                                                                                                                                      ) => asserts node is FunctionParent;

                                                                                                                                                        function assertFunctionTypeAnnotation

                                                                                                                                                        assertFunctionTypeAnnotation: (
                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                        opts?: object
                                                                                                                                                        ) => asserts node is FunctionTypeAnnotation;

                                                                                                                                                          function assertFunctionTypeParam

                                                                                                                                                          assertFunctionTypeParam: (
                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                          opts?: object
                                                                                                                                                          ) => asserts node is FunctionTypeParam;

                                                                                                                                                            function assertGenericTypeAnnotation

                                                                                                                                                            assertGenericTypeAnnotation: (
                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                            opts?: object
                                                                                                                                                            ) => asserts node is GenericTypeAnnotation;

                                                                                                                                                              function assertIdentifier

                                                                                                                                                              assertIdentifier: (
                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                              opts?: object
                                                                                                                                                              ) => asserts node is Identifier;

                                                                                                                                                                function assertIfStatement

                                                                                                                                                                assertIfStatement: (
                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                opts?: object
                                                                                                                                                                ) => asserts node is IfStatement;

                                                                                                                                                                  function assertImmutable

                                                                                                                                                                  assertImmutable: (
                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                  opts?: object
                                                                                                                                                                  ) => asserts node is Immutable;

                                                                                                                                                                    function assertImportDeclaration

                                                                                                                                                                    assertImportDeclaration: (
                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                    opts?: object
                                                                                                                                                                    ) => asserts node is ImportDeclaration;

                                                                                                                                                                      function assertImportDefaultSpecifier

                                                                                                                                                                      assertImportDefaultSpecifier: (
                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                      opts?: object
                                                                                                                                                                      ) => asserts node is ImportDefaultSpecifier;

                                                                                                                                                                        function assertImportNamespaceSpecifier

                                                                                                                                                                        assertImportNamespaceSpecifier: (
                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                        opts?: object
                                                                                                                                                                        ) => asserts node is ImportNamespaceSpecifier;

                                                                                                                                                                          function assertImportSpecifier

                                                                                                                                                                          assertImportSpecifier: (
                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                          opts?: object
                                                                                                                                                                          ) => asserts node is ImportSpecifier;

                                                                                                                                                                            function assertInterfaceDeclaration

                                                                                                                                                                            assertInterfaceDeclaration: (
                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                            opts?: object
                                                                                                                                                                            ) => asserts node is InterfaceDeclaration;

                                                                                                                                                                              function assertInterfaceExtends

                                                                                                                                                                              assertInterfaceExtends: (
                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                              opts?: object
                                                                                                                                                                              ) => asserts node is InterfaceExtends;

                                                                                                                                                                                function assertIntersectionTypeAnnotation

                                                                                                                                                                                assertIntersectionTypeAnnotation: (
                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                opts?: object
                                                                                                                                                                                ) => asserts node is IntersectionTypeAnnotation;

                                                                                                                                                                                  function assertJSX

                                                                                                                                                                                  assertJSX: (
                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                  opts?: object
                                                                                                                                                                                  ) => asserts node is JSX;

                                                                                                                                                                                    function assertJSXAttribute

                                                                                                                                                                                    assertJSXAttribute: (
                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                    opts?: object
                                                                                                                                                                                    ) => asserts node is JSXAttribute;

                                                                                                                                                                                      function assertJSXClosingElement

                                                                                                                                                                                      assertJSXClosingElement: (
                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                      opts?: object
                                                                                                                                                                                      ) => asserts node is JSXClosingElement;

                                                                                                                                                                                        function assertJSXElement

                                                                                                                                                                                        assertJSXElement: (
                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                        opts?: object
                                                                                                                                                                                        ) => asserts node is JSXElement;

                                                                                                                                                                                          function assertJSXEmptyExpression

                                                                                                                                                                                          assertJSXEmptyExpression: (
                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                          opts?: object
                                                                                                                                                                                          ) => asserts node is JSXEmptyExpression;

                                                                                                                                                                                            function assertJSXExpressionContainer

                                                                                                                                                                                            assertJSXExpressionContainer: (
                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                            opts?: object
                                                                                                                                                                                            ) => asserts node is JSXExpressionContainer;

                                                                                                                                                                                              function assertJSXIdentifier

                                                                                                                                                                                              assertJSXIdentifier: (
                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                              opts?: object
                                                                                                                                                                                              ) => asserts node is JSXIdentifier;

                                                                                                                                                                                                function assertJSXMemberExpression

                                                                                                                                                                                                assertJSXMemberExpression: (
                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                ) => asserts node is JSXMemberExpression;

                                                                                                                                                                                                  function assertJSXNamespacedName

                                                                                                                                                                                                  assertJSXNamespacedName: (
                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                  ) => asserts node is JSXNamespacedName;

                                                                                                                                                                                                    function assertJSXOpeningElement

                                                                                                                                                                                                    assertJSXOpeningElement: (
                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                    ) => asserts node is JSXOpeningElement;

                                                                                                                                                                                                      function assertJSXSpreadAttribute

                                                                                                                                                                                                      assertJSXSpreadAttribute: (
                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                      ) => asserts node is JSXSpreadAttribute;

                                                                                                                                                                                                        function assertJSXText

                                                                                                                                                                                                        assertJSXText: (
                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                        ) => asserts node is JSXText;

                                                                                                                                                                                                          function assertLabeledStatement

                                                                                                                                                                                                          assertLabeledStatement: (
                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                          ) => asserts node is LabeledStatement;

                                                                                                                                                                                                            function assertLiteral

                                                                                                                                                                                                            assertLiteral: (
                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                            ) => asserts node is Literal;

                                                                                                                                                                                                              function assertLogicalExpression

                                                                                                                                                                                                              assertLogicalExpression: (
                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                              ) => asserts node is LogicalExpression;

                                                                                                                                                                                                                function assertLoop

                                                                                                                                                                                                                assertLoop: (
                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                ) => asserts node is Loop;

                                                                                                                                                                                                                  function assertLVal

                                                                                                                                                                                                                  assertLVal: (
                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                  ) => asserts node is LVal;

                                                                                                                                                                                                                    function assertMemberExpression

                                                                                                                                                                                                                    assertMemberExpression: (
                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                    ) => asserts node is MemberExpression;

                                                                                                                                                                                                                      function assertMetaProperty

                                                                                                                                                                                                                      assertMetaProperty: (
                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                      ) => asserts node is MetaProperty;

                                                                                                                                                                                                                        function assertMethod

                                                                                                                                                                                                                        assertMethod: (
                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                        ) => asserts node is Method;

                                                                                                                                                                                                                          function assertMixedTypeAnnotation

                                                                                                                                                                                                                          assertMixedTypeAnnotation: (
                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                          ) => asserts node is MixedTypeAnnotation;

                                                                                                                                                                                                                            function assertModuleDeclaration

                                                                                                                                                                                                                            assertModuleDeclaration: (
                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                            ) => asserts node is ModuleDeclaration;

                                                                                                                                                                                                                              function assertModuleSpecifier

                                                                                                                                                                                                                              assertModuleSpecifier: (
                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                              ) => asserts node is ModuleSpecifier;

                                                                                                                                                                                                                                function assertNewExpression

                                                                                                                                                                                                                                assertNewExpression: (
                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                ) => asserts node is NewExpression;

                                                                                                                                                                                                                                  function assertNoop

                                                                                                                                                                                                                                  assertNoop: (
                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                  ) => asserts node is Noop;

                                                                                                                                                                                                                                    function assertNullableTypeAnnotation

                                                                                                                                                                                                                                    assertNullableTypeAnnotation: (
                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                    ) => asserts node is NullableTypeAnnotation;

                                                                                                                                                                                                                                      function assertNullLiteral

                                                                                                                                                                                                                                      assertNullLiteral: (
                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                      ) => asserts node is NullLiteral;

                                                                                                                                                                                                                                        function assertNullLiteralTypeAnnotation

                                                                                                                                                                                                                                        assertNullLiteralTypeAnnotation: (
                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                        ) => asserts node is NullLiteralTypeAnnotation;

                                                                                                                                                                                                                                          function assertNumberLiteral

                                                                                                                                                                                                                                          assertNumberLiteral: (
                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                          ) => asserts node is NumericLiteral;
                                                                                                                                                                                                                                          • Deprecated

                                                                                                                                                                                                                                            Use assertNumericLiteral

                                                                                                                                                                                                                                          function assertNumberTypeAnnotation

                                                                                                                                                                                                                                          assertNumberTypeAnnotation: (
                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                          ) => asserts node is NumberTypeAnnotation;

                                                                                                                                                                                                                                            function assertNumericLiteral

                                                                                                                                                                                                                                            assertNumericLiteral: (
                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                            ) => asserts node is NumericLiteral;

                                                                                                                                                                                                                                              function assertNumericLiteralTypeAnnotation

                                                                                                                                                                                                                                              assertNumericLiteralTypeAnnotation: (
                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                              ) => asserts node is NumericLiteralTypeAnnotation;

                                                                                                                                                                                                                                                function assertObjectExpression

                                                                                                                                                                                                                                                assertObjectExpression: (
                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                ) => asserts node is ObjectExpression;

                                                                                                                                                                                                                                                  function assertObjectMember

                                                                                                                                                                                                                                                  assertObjectMember: (
                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                  ) => asserts node is ObjectMember;

                                                                                                                                                                                                                                                    function assertObjectMethod

                                                                                                                                                                                                                                                    assertObjectMethod: (
                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                    ) => asserts node is ObjectMethod;

                                                                                                                                                                                                                                                      function assertObjectPattern

                                                                                                                                                                                                                                                      assertObjectPattern: (
                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                      ) => asserts node is ObjectPattern;

                                                                                                                                                                                                                                                        function assertObjectProperty

                                                                                                                                                                                                                                                        assertObjectProperty: (
                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                        ) => asserts node is ObjectProperty;

                                                                                                                                                                                                                                                          function assertObjectTypeAnnotation

                                                                                                                                                                                                                                                          assertObjectTypeAnnotation: (
                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                          ) => asserts node is ObjectTypeAnnotation;

                                                                                                                                                                                                                                                            function assertObjectTypeCallProperty

                                                                                                                                                                                                                                                            assertObjectTypeCallProperty: (
                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                            ) => asserts node is ObjectTypeCallProperty;

                                                                                                                                                                                                                                                              function assertObjectTypeIndexer

                                                                                                                                                                                                                                                              assertObjectTypeIndexer: (
                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                              ) => asserts node is ObjectTypeIndexer;

                                                                                                                                                                                                                                                                function assertObjectTypeProperty

                                                                                                                                                                                                                                                                assertObjectTypeProperty: (
                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                ) => asserts node is ObjectTypeProperty;

                                                                                                                                                                                                                                                                  function assertParenthesizedExpression

                                                                                                                                                                                                                                                                  assertParenthesizedExpression: (
                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                  ) => asserts node is ParenthesizedExpression;

                                                                                                                                                                                                                                                                    function assertPattern

                                                                                                                                                                                                                                                                    assertPattern: (
                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                    ) => asserts node is Pattern;

                                                                                                                                                                                                                                                                      function assertProgram

                                                                                                                                                                                                                                                                      assertProgram: (
                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                      ) => asserts node is Program;

                                                                                                                                                                                                                                                                        function assertProperty

                                                                                                                                                                                                                                                                        assertProperty: (
                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                        ) => asserts node is Property;

                                                                                                                                                                                                                                                                          function assertPureish

                                                                                                                                                                                                                                                                          assertPureish: (
                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                          ) => asserts node is Pureish;

                                                                                                                                                                                                                                                                            function assertQualifiedTypeIdentifier

                                                                                                                                                                                                                                                                            assertQualifiedTypeIdentifier: (
                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                            ) => asserts node is QualifiedTypeIdentifier;

                                                                                                                                                                                                                                                                              function assertRegexLiteral

                                                                                                                                                                                                                                                                              assertRegexLiteral: (
                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                              ) => asserts node is RegExpLiteral;
                                                                                                                                                                                                                                                                              • Deprecated

                                                                                                                                                                                                                                                                                Use assertRegExpLiteral

                                                                                                                                                                                                                                                                              function assertRegExpLiteral

                                                                                                                                                                                                                                                                              assertRegExpLiteral: (
                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                              ) => asserts node is RegExpLiteral;

                                                                                                                                                                                                                                                                                function assertRestElement

                                                                                                                                                                                                                                                                                assertRestElement: (
                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                ) => asserts node is RestElement;

                                                                                                                                                                                                                                                                                  function assertRestProperty

                                                                                                                                                                                                                                                                                  assertRestProperty: (
                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                  ) => asserts node is RestProperty;

                                                                                                                                                                                                                                                                                    function assertReturnStatement

                                                                                                                                                                                                                                                                                    assertReturnStatement: (
                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                    ) => asserts node is ReturnStatement;

                                                                                                                                                                                                                                                                                      function assertScopable

                                                                                                                                                                                                                                                                                      assertScopable: (
                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                      ) => asserts node is Scopable;

                                                                                                                                                                                                                                                                                        function assertSequenceExpression

                                                                                                                                                                                                                                                                                        assertSequenceExpression: (
                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                        ) => asserts node is SequenceExpression;

                                                                                                                                                                                                                                                                                          function assertSpreadElement

                                                                                                                                                                                                                                                                                          assertSpreadElement: (
                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                          ) => asserts node is SpreadElement;

                                                                                                                                                                                                                                                                                            function assertSpreadProperty

                                                                                                                                                                                                                                                                                            assertSpreadProperty: (
                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                            ) => asserts node is SpreadProperty;

                                                                                                                                                                                                                                                                                              function assertStatement

                                                                                                                                                                                                                                                                                              assertStatement: (
                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                              ) => asserts node is Statement;

                                                                                                                                                                                                                                                                                                function assertStringLiteral

                                                                                                                                                                                                                                                                                                assertStringLiteral: (
                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                ) => asserts node is StringLiteral;

                                                                                                                                                                                                                                                                                                  function assertStringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                  assertStringLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                  ) => asserts node is StringLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                    function assertStringTypeAnnotation

                                                                                                                                                                                                                                                                                                    assertStringTypeAnnotation: (
                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                    ) => asserts node is StringTypeAnnotation;

                                                                                                                                                                                                                                                                                                      function assertSuper

                                                                                                                                                                                                                                                                                                      assertSuper: (
                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                      ) => asserts node is Super;

                                                                                                                                                                                                                                                                                                        function assertSwitchCase

                                                                                                                                                                                                                                                                                                        assertSwitchCase: (
                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                        ) => asserts node is SwitchCase;

                                                                                                                                                                                                                                                                                                          function assertSwitchStatement

                                                                                                                                                                                                                                                                                                          assertSwitchStatement: (
                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                          ) => asserts node is SwitchStatement;

                                                                                                                                                                                                                                                                                                            function assertTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                            assertTaggedTemplateExpression: (
                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                            ) => asserts node is TaggedTemplateExpression;

                                                                                                                                                                                                                                                                                                              function assertTemplateElement

                                                                                                                                                                                                                                                                                                              assertTemplateElement: (
                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                              ) => asserts node is TemplateElement;

                                                                                                                                                                                                                                                                                                                function assertTemplateLiteral

                                                                                                                                                                                                                                                                                                                assertTemplateLiteral: (
                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                ) => asserts node is TemplateLiteral;

                                                                                                                                                                                                                                                                                                                  function assertTerminatorless

                                                                                                                                                                                                                                                                                                                  assertTerminatorless: (
                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                  ) => asserts node is Terminatorless;

                                                                                                                                                                                                                                                                                                                    function assertThisExpression

                                                                                                                                                                                                                                                                                                                    assertThisExpression: (
                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                    ) => asserts node is ThisExpression;

                                                                                                                                                                                                                                                                                                                      function assertThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                      assertThisTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                      ) => asserts node is ThisTypeAnnotation;

                                                                                                                                                                                                                                                                                                                        function assertThrowStatement

                                                                                                                                                                                                                                                                                                                        assertThrowStatement: (
                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                        ) => asserts node is ThrowStatement;

                                                                                                                                                                                                                                                                                                                          function assertTryStatement

                                                                                                                                                                                                                                                                                                                          assertTryStatement: (
                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                          ) => asserts node is TryStatement;

                                                                                                                                                                                                                                                                                                                            function assertTSAnyKeyword

                                                                                                                                                                                                                                                                                                                            assertTSAnyKeyword: (
                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSAnyKeyword;

                                                                                                                                                                                                                                                                                                                              function assertTSArrayType

                                                                                                                                                                                                                                                                                                                              assertTSArrayType: (
                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSArrayType;

                                                                                                                                                                                                                                                                                                                                function assertTSAsExpression

                                                                                                                                                                                                                                                                                                                                assertTSAsExpression: (
                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSAsExpression;

                                                                                                                                                                                                                                                                                                                                  function assertTSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                  assertTSBooleanKeyword: (
                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSBooleanKeyword;

                                                                                                                                                                                                                                                                                                                                    function assertTSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                    assertTSCallSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSCallSignatureDeclaration;

                                                                                                                                                                                                                                                                                                                                      function assertTSConstructorType

                                                                                                                                                                                                                                                                                                                                      assertTSConstructorType: (
                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSConstructorType;

                                                                                                                                                                                                                                                                                                                                        function assertTSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                        assertTSConstructSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSConstructSignatureDeclaration;

                                                                                                                                                                                                                                                                                                                                          function assertTSDeclareFunction

                                                                                                                                                                                                                                                                                                                                          assertTSDeclareFunction: (
                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSDeclareFunction;

                                                                                                                                                                                                                                                                                                                                            function assertTSDeclareMethod

                                                                                                                                                                                                                                                                                                                                            assertTSDeclareMethod: (
                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSDeclareMethod;

                                                                                                                                                                                                                                                                                                                                              function assertTSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                              assertTSEnumDeclaration: (
                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSEnumDeclaration;

                                                                                                                                                                                                                                                                                                                                                function assertTSEnumMember

                                                                                                                                                                                                                                                                                                                                                assertTSEnumMember: (
                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSEnumMember;

                                                                                                                                                                                                                                                                                                                                                  function assertTSExportAssignment

                                                                                                                                                                                                                                                                                                                                                  assertTSExportAssignment: (
                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSExportAssignment;

                                                                                                                                                                                                                                                                                                                                                    function assertTSExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                    assertTSExpressionWithTypeArguments: (
                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSExpressionWithTypeArguments;

                                                                                                                                                                                                                                                                                                                                                      function assertTSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                      assertTSExternalModuleReference: (
                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSExternalModuleReference;

                                                                                                                                                                                                                                                                                                                                                        function assertTSFunctionType

                                                                                                                                                                                                                                                                                                                                                        assertTSFunctionType: (
                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSFunctionType;

                                                                                                                                                                                                                                                                                                                                                          function assertTSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                          assertTSImportEqualsDeclaration: (
                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSImportEqualsDeclaration;

                                                                                                                                                                                                                                                                                                                                                            function assertTSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                            assertTSIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSIndexedAccessType;

                                                                                                                                                                                                                                                                                                                                                              function assertTSIndexSignature

                                                                                                                                                                                                                                                                                                                                                              assertTSIndexSignature: (
                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSIndexSignature;

                                                                                                                                                                                                                                                                                                                                                                function assertTSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                assertTSInterfaceBody: (
                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSInterfaceBody;

                                                                                                                                                                                                                                                                                                                                                                  function assertTSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                  assertTSInterfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSInterfaceDeclaration;

                                                                                                                                                                                                                                                                                                                                                                    function assertTSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                    assertTSIntersectionType: (
                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSIntersectionType;

                                                                                                                                                                                                                                                                                                                                                                      function assertTSLiteralType

                                                                                                                                                                                                                                                                                                                                                                      assertTSLiteralType: (
                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSLiteralType;

                                                                                                                                                                                                                                                                                                                                                                        function assertTSMappedType

                                                                                                                                                                                                                                                                                                                                                                        assertTSMappedType: (
                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSMappedType;

                                                                                                                                                                                                                                                                                                                                                                          function assertTSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                          assertTSMethodSignature: (
                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSMethodSignature;

                                                                                                                                                                                                                                                                                                                                                                            function assertTSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                            assertTSModuleBlock: (
                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSModuleBlock;

                                                                                                                                                                                                                                                                                                                                                                              function assertTSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                              assertTSModuleDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSModuleDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                function assertTSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                assertTSNamespaceExportDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSNamespaceExportDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                  function assertTSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                  assertTSNeverKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSNeverKeyword;

                                                                                                                                                                                                                                                                                                                                                                                    function assertTSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                    assertTSNonNullExpression: (
                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSNonNullExpression;

                                                                                                                                                                                                                                                                                                                                                                                      function assertTSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                      assertTSNullKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSNullKeyword;

                                                                                                                                                                                                                                                                                                                                                                                        function assertTSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                        assertTSNumberKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSNumberKeyword;

                                                                                                                                                                                                                                                                                                                                                                                          function assertTSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                          assertTSObjectKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSObjectKeyword;

                                                                                                                                                                                                                                                                                                                                                                                            function assertTSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                            assertTSParameterProperty: (
                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSParameterProperty;

                                                                                                                                                                                                                                                                                                                                                                                              function assertTSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                              assertTSParenthesizedType: (
                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSParenthesizedType;

                                                                                                                                                                                                                                                                                                                                                                                                function assertTSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                assertTSPropertySignature: (
                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSPropertySignature;

                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                  assertTSQualifiedName: (
                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSQualifiedName;

                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                    assertTSStringKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSStringKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                      assertTSSymbolKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSSymbolKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSThisType

                                                                                                                                                                                                                                                                                                                                                                                                        assertTSThisType: (
                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSThisType;

                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                          assertTSTupleType: (
                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSTupleType;

                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                            assertTSTypeAliasDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSTypeAliasDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                              assertTSTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTypeAssertion: (
                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSTypeAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSTypeLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSTypeLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSTypeOperator: (
                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSTypeOperator;

                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSTypeParameter;

                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TSTypeParameterDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TSTypeParameterInstantiation;

                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSTypePredicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TSTypePredicate;

                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSTypeQuery: (
                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TSTypeQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTypeReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TSTypeReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSUndefinedKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TSUndefinedKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSUnionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TSUnionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSVoidKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TSVoidKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTupleTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is TupleTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTypeAlias: (
                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is TypeAlias;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is TypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTypeCastExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is TypeCastExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTypeofTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is TypeofTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is TypeParameter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is TypeParameterDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is TypeParameterInstantiation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertUnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertUnaryExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is UnaryExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertUnaryLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertUnaryLike: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is UnaryLike;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertUnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertUnionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is UnionTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertUpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertUpdateExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is UpdateExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertUserWhitespacable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertUserWhitespacable: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => asserts node is UserWhitespacable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertVariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertVariableDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => asserts node is VariableDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertVariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertVariableDeclarator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => asserts node is VariableDeclarator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertVoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertVoidTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => asserts node is VoidTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertWhile

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertWhile: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => asserts node is While;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertWhileStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => asserts node is WhileStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertWithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertWithStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => asserts node is WithStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertYieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertYieldExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => asserts node is YieldExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assignmentExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                operator?: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                left?: LVal,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                right?: Expression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => AssignmentExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assignmentPattern: (left?: Identifier, right?: Expression) => AssignmentPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function awaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    awaitExpression: (argument?: Expression) => AwaitExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function binaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      binaryExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      operator?:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '+'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '-'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '/'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '%'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '*'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '**'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '&'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '|'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '>>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '>>>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '<<'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '^'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '=='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '==='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '!='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '!=='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'in'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 'instanceof'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '>'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '<'
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '>='
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | '<=',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      left?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      right?: Expression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => BinaryExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function bindExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        bindExpression: (object?: Expression, callee?: Expression) => BindExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function blockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          blockStatement: (body?: Statement[], directives?: Directive[]) => BlockStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function booleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            booleanLiteral: (value?: boolean) => BooleanLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function booleanLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              booleanLiteralTypeAnnotation: () => BooleanLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function booleanTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                booleanTypeAnnotation: () => BooleanTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function breakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  breakStatement: (label?: Identifier) => BreakStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function callExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    callee?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    _arguments?: Array<Expression | SpreadElement>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => CallExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function catchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      catchClause: (param?: Identifier, body?: BlockStatement) => CatchClause;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function classBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        classBody: (body?: Array<ClassMethod | ClassProperty>) => ClassBody;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function classDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          classDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          superClass?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: ClassBody,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          decorators?: Decorator[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ClassDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function classExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            classExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            superClass?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            body?: ClassBody,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            decorators?: Decorator[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => ClassExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function classImplements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              classImplements: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeParameters?: TypeParameterInstantiation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => ClassImplements;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function classMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                classMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                kind?: 'constructor' | 'method' | 'get' | 'set',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                key?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                params?: LVal[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body?: BlockStatement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                computed?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _static?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => ClassMethod;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function classProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  classProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  key?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  value?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeAnnotation?: TypeAnnotation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  decorators?: Decorator[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => ClassProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function conditionalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    conditionalExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    test?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    consequent?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    alternate?: Expression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ConditionalExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function continueStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      continueStatement: (label?: Identifier) => ContinueStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function debuggerStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        debuggerStatement: () => DebuggerStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function declareClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          declareClass: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          typeParameters?: TypeParameterDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          _extends?: InterfaceExtends[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: ObjectTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => DeclareClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function declareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            declareFunction: (id?: Identifier) => DeclareFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function declareInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              declareInterface: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeParameters?: TypeParameterDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              _extends?: InterfaceExtends[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              body?: ObjectTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => DeclareInterface;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function declareModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                declareModule: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: StringLiteral | Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body?: BlockStatement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => DeclareModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function declareTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  declareTypeAlias: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeParameters?: TypeParameterDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  right?: FlowTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => DeclareTypeAlias;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function declareVariable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    declareVariable: (id?: Identifier) => DeclareVariable;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function decorator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      decorator: (expression?: Expression) => Decorator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function directive

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        directive: (value?: DirectiveLiteral) => Directive;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function directiveLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          directiveLiteral: (value?: string) => DirectiveLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function doExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            doExpression: (body?: BlockStatement) => DoExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function doWhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              doWhileStatement: (test?: Expression, body?: Statement) => DoWhileStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function emptyStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                emptyStatement: () => EmptyStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function existentialTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  existentialTypeParam: () => ExistentialTypeParam;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function exportAllDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    exportAllDeclaration: (source?: StringLiteral) => ExportAllDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function exportDefaultDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      exportDefaultDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      declaration?: FunctionDeclaration | ClassDeclaration | Expression
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ExportDefaultDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function exportDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        exportDefaultSpecifier: (exported?: Identifier) => ExportDefaultSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function exportNamedDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          exportNamedDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          declaration?: Declaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          specifiers?: ExportSpecifier[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          source?: StringLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => ExportNamedDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function exportNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            exportNamespaceSpecifier: (exported?: Identifier) => ExportNamespaceSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function exportSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              exportSpecifier: (local?: Identifier, exported?: Identifier) => ExportSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function expressionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                expressionStatement: (expression?: Expression) => ExpressionStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function file

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  file: (program?: Program, comments?: Comment[], tokens?: any[]) => File;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function forInStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    forInStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    left?: VariableDeclaration | LVal,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    right?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    body?: Statement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => ForInStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function forOfStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      forOfStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      left?: VariableDeclaration | LVal,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      right?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      body?: Statement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => ForOfStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function forStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        forStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        init?: VariableDeclaration | Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        test?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        update?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        body?: Statement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ForStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function functionDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          functionDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          params?: LVal[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          body?: BlockStatement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          generator?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          async?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => FunctionDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function functionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            functionExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            params?: LVal[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            body?: BlockStatement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            generator?: boolean,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            async?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => FunctionExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function functionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              functionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              typeParameters?: TypeParameterDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              params?: FunctionTypeParam[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              rest?: FunctionTypeParam,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              returnType?: FlowTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => FunctionTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function functionTypeParam

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                functionTypeParam: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                name?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typeAnnotation?: FlowTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => FunctionTypeParam;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function genericTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  genericTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeParameters?: TypeParameterInstantiation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => GenericTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function identifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    identifier: (name?: string) => Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function ifStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ifStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      test?: Expression,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      consequent?: Statement,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      alternate?: Statement
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => IfStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function importDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        importDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        specifiers?: Array<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        source?: StringLiteral
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => ImportDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function importDefaultSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          importDefaultSpecifier: (local?: Identifier) => ImportDefaultSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function importNamespaceSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            importNamespaceSpecifier: (local?: Identifier) => ImportNamespaceSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function importSpecifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              importSpecifier: (local?: Identifier, imported?: Identifier) => ImportSpecifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function interfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                typeParameters?: TypeParameterDeclaration,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                _extends?: InterfaceExtends[],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                body?: ObjectTypeAnnotation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => InterfaceDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function interfaceExtends

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interfaceExtends: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  id?: Identifier,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  typeParameters?: TypeParameterInstantiation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => InterfaceExtends;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function intersectionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    intersectionTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    types?: FlowTypeAnnotation[]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => IntersectionTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isAnyTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isAnyTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => node is AnyTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function isArrayExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isArrayExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => node is ArrayExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isArrayPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isArrayPattern: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => node is ArrayPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isArrayTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isArrayTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => node is ArrayTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isArrowFunctionExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isArrowFunctionExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => node is ArrowFunctionExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isAssignmentExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isAssignmentExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => node is AssignmentExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isAssignmentPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isAssignmentPattern: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => node is AssignmentPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isAwaitExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isAwaitExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => node is AwaitExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isBinary

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBinary: (node: object | null | undefined, opts?: object) => node is Binary;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function isBinaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBinaryExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => node is BinaryExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isBindExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBindExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => node is BindExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isBindingIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isBindingIdentifier: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => node is Identifier;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBlock: (node: object | null | undefined, opts?: object) => node is Block;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isBlockParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isBlockParent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => node is BlockParent;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isBlockScoped

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isBlockScoped: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => node is FunctionDeclaration | VariableDeclaration | ClassDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isBlockStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isBlockStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => node is BlockStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isBooleanLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isBooleanLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => node is BooleanLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function isBooleanLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isBooleanLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => node is BooleanLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isBooleanTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isBooleanTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => node is BooleanTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isBreakStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isBreakStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => node is BreakStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isCallExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isCallExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => node is CallExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isCatchClause

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isCatchClause: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => node is CatchClause;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isClass: (node: object | null | undefined, opts?: object) => node is Class;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isClassBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isClassBody: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => node is ClassBody;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isClassDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isClassDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => node is ClassDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function isClassExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isClassExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => node is ClassExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isClassImplements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isClassImplements: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => node is ClassImplements;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isClassMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isClassMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => node is ClassMethod;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isClassProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isClassProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => node is ClassProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isCompletionStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isCompletionStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => node is CompletionStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isConditional

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isConditional: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => node is Conditional;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isConditionalExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isConditionalExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => node is ConditionalExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function isContinueStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isContinueStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => node is ContinueStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function isDebuggerStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isDebuggerStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => node is DebuggerStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function isDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          isDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => node is Declaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function isDeclareClass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isDeclareClass: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => node is DeclareClass;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function isDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDeclareFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => node is DeclareFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function isDeclareInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isDeclareInterface: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => node is DeclareInterface;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function isDeclareModule

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isDeclareModule: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => node is DeclareModule;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function isDeclareTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    isDeclareTypeAlias: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )