jsDocs.io logo

@babel/types

  • Version 7.14.4
  • Published
  • 1 MB
  • 2 dependencies
  • MIT license

Install

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

Overview

Babel Types is a Lodash-esque utility library for AST nodes

Index

Functions

Interfaces

Type Aliases

Functions

function addComment

addComment: <T extends Node>(
    node: T,
    type: CommentTypeShorthand,
    content: string,
    line?: boolean
) => T;

    function addComments

    addComments: <T extends Node>(
        node: T,
        type: CommentTypeShorthand,
        comments: ReadonlyArray<Comment>
    ) => T;

      function anyTypeAnnotation

      anyTypeAnnotation: () => AnyTypeAnnotation;

        function appendToMemberExpression

        appendToMemberExpression: <
            T extends Pick<MemberExpression, 'object' | 'property'>
        >(
            member: T,
            append: MemberExpression['property'],
            computed?: boolean
        ) => T;

          function argumentPlaceholder

          argumentPlaceholder: () => ArgumentPlaceholder;

            function arrayExpression

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

              function arrayPattern

              arrayPattern: (elements: Array<null | PatternLike>) => ArrayPattern;

                function arrayTypeAnnotation

                arrayTypeAnnotation: (elementType: FlowType) => ArrayTypeAnnotation;

                  function arrowFunctionExpression

                  arrowFunctionExpression: (
                      params: Array<Identifier | Pattern | RestElement>,
                      body: BlockStatement | Expression,
                      async?: boolean
                  ) => ArrowFunctionExpression;

                    function assertAnyTypeAnnotation

                    assertAnyTypeAnnotation: (
                        node: object | null | undefined,
                        opts?: object | null
                    ) => void;

                      function assertArgumentPlaceholder

                      assertArgumentPlaceholder: (
                          node: object | null | undefined,
                          opts?: object | null
                      ) => void;

                        function assertArrayExpression

                        assertArrayExpression: (
                            node: object | null | undefined,
                            opts?: object | null
                        ) => void;

                          function assertArrayPattern

                          assertArrayPattern: (
                              node: object | null | undefined,
                              opts?: object | null
                          ) => void;

                            function assertArrayTypeAnnotation

                            assertArrayTypeAnnotation: (
                                node: object | null | undefined,
                                opts?: object | null
                            ) => void;

                              function assertArrowFunctionExpression

                              assertArrowFunctionExpression: (
                                  node: object | null | undefined,
                                  opts?: object | null
                              ) => void;

                                function assertAssignmentExpression

                                assertAssignmentExpression: (
                                    node: object | null | undefined,
                                    opts?: object | null
                                ) => void;

                                  function assertAssignmentPattern

                                  assertAssignmentPattern: (
                                      node: object | null | undefined,
                                      opts?: object | null
                                  ) => void;

                                    function assertAwaitExpression

                                    assertAwaitExpression: (
                                        node: object | null | undefined,
                                        opts?: object | null
                                    ) => void;

                                      function assertBigIntLiteral

                                      assertBigIntLiteral: (
                                          node: object | null | undefined,
                                          opts?: object | null
                                      ) => void;

                                        function assertBinary

                                        assertBinary: (node: object | null | undefined, opts?: object | null) => void;

                                          function assertBinaryExpression

                                          assertBinaryExpression: (
                                              node: object | null | undefined,
                                              opts?: object | null
                                          ) => void;

                                            function assertBindExpression

                                            assertBindExpression: (
                                                node: object | null | undefined,
                                                opts?: object | null
                                            ) => void;

                                              function assertBlock

                                              assertBlock: (node: object | null | undefined, opts?: object | null) => void;

                                                function assertBlockParent

                                                assertBlockParent: (
                                                    node: object | null | undefined,
                                                    opts?: object | null
                                                ) => void;

                                                  function assertBlockStatement

                                                  assertBlockStatement: (
                                                      node: object | null | undefined,
                                                      opts?: object | null
                                                  ) => void;

                                                    function assertBooleanLiteral

                                                    assertBooleanLiteral: (
                                                        node: object | null | undefined,
                                                        opts?: object | null
                                                    ) => void;

                                                      function assertBooleanLiteralTypeAnnotation

                                                      assertBooleanLiteralTypeAnnotation: (
                                                          node: object | null | undefined,
                                                          opts?: object | null
                                                      ) => void;

                                                        function assertBooleanTypeAnnotation

                                                        assertBooleanTypeAnnotation: (
                                                            node: object | null | undefined,
                                                            opts?: object | null
                                                        ) => void;

                                                          function assertBreakStatement

                                                          assertBreakStatement: (
                                                              node: object | null | undefined,
                                                              opts?: object | null
                                                          ) => void;

                                                            function assertCallExpression

                                                            assertCallExpression: (
                                                                node: object | null | undefined,
                                                                opts?: object | null
                                                            ) => void;

                                                              function assertCatchClause

                                                              assertCatchClause: (
                                                                  node: object | null | undefined,
                                                                  opts?: object | null
                                                              ) => void;

                                                                function assertClass

                                                                assertClass: (node: object | null | undefined, opts?: object | null) => void;

                                                                  function assertClassBody

                                                                  assertClassBody: (node: object | null | undefined, opts?: object | null) => void;

                                                                    function assertClassDeclaration

                                                                    assertClassDeclaration: (
                                                                        node: object | null | undefined,
                                                                        opts?: object | null
                                                                    ) => void;

                                                                      function assertClassExpression

                                                                      assertClassExpression: (
                                                                          node: object | null | undefined,
                                                                          opts?: object | null
                                                                      ) => void;

                                                                        function assertClassImplements

                                                                        assertClassImplements: (
                                                                            node: object | null | undefined,
                                                                            opts?: object | null
                                                                        ) => void;

                                                                          function assertClassMethod

                                                                          assertClassMethod: (
                                                                              node: object | null | undefined,
                                                                              opts?: object | null
                                                                          ) => void;

                                                                            function assertClassPrivateMethod

                                                                            assertClassPrivateMethod: (
                                                                                node: object | null | undefined,
                                                                                opts?: object | null
                                                                            ) => void;

                                                                              function assertClassPrivateProperty

                                                                              assertClassPrivateProperty: (
                                                                                  node: object | null | undefined,
                                                                                  opts?: object | null
                                                                              ) => void;

                                                                                function assertClassProperty

                                                                                assertClassProperty: (
                                                                                    node: object | null | undefined,
                                                                                    opts?: object | null
                                                                                ) => void;

                                                                                  function assertCompletionStatement

                                                                                  assertCompletionStatement: (
                                                                                      node: object | null | undefined,
                                                                                      opts?: object | null
                                                                                  ) => void;

                                                                                    function assertConditional

                                                                                    assertConditional: (
                                                                                        node: object | null | undefined,
                                                                                        opts?: object | null
                                                                                    ) => void;

                                                                                      function assertConditionalExpression

                                                                                      assertConditionalExpression: (
                                                                                          node: object | null | undefined,
                                                                                          opts?: object | null
                                                                                      ) => void;

                                                                                        function assertContinueStatement

                                                                                        assertContinueStatement: (
                                                                                            node: object | null | undefined,
                                                                                            opts?: object | null
                                                                                        ) => void;

                                                                                          function assertDebuggerStatement

                                                                                          assertDebuggerStatement: (
                                                                                              node: object | null | undefined,
                                                                                              opts?: object | null
                                                                                          ) => void;

                                                                                            function assertDecimalLiteral

                                                                                            assertDecimalLiteral: (
                                                                                                node: object | null | undefined,
                                                                                                opts?: object | null
                                                                                            ) => void;

                                                                                              function assertDeclaration

                                                                                              assertDeclaration: (
                                                                                                  node: object | null | undefined,
                                                                                                  opts?: object | null
                                                                                              ) => void;

                                                                                                function assertDeclareClass

                                                                                                assertDeclareClass: (
                                                                                                    node: object | null | undefined,
                                                                                                    opts?: object | null
                                                                                                ) => void;

                                                                                                  function assertDeclaredPredicate

                                                                                                  assertDeclaredPredicate: (
                                                                                                      node: object | null | undefined,
                                                                                                      opts?: object | null
                                                                                                  ) => void;

                                                                                                    function assertDeclareExportAllDeclaration

                                                                                                    assertDeclareExportAllDeclaration: (
                                                                                                        node: object | null | undefined,
                                                                                                        opts?: object | null
                                                                                                    ) => void;

                                                                                                      function assertDeclareExportDeclaration

                                                                                                      assertDeclareExportDeclaration: (
                                                                                                          node: object | null | undefined,
                                                                                                          opts?: object | null
                                                                                                      ) => void;

                                                                                                        function assertDeclareFunction

                                                                                                        assertDeclareFunction: (
                                                                                                            node: object | null | undefined,
                                                                                                            opts?: object | null
                                                                                                        ) => void;

                                                                                                          function assertDeclareInterface

                                                                                                          assertDeclareInterface: (
                                                                                                              node: object | null | undefined,
                                                                                                              opts?: object | null
                                                                                                          ) => void;

                                                                                                            function assertDeclareModule

                                                                                                            assertDeclareModule: (
                                                                                                                node: object | null | undefined,
                                                                                                                opts?: object | null
                                                                                                            ) => void;

                                                                                                              function assertDeclareModuleExports

                                                                                                              assertDeclareModuleExports: (
                                                                                                                  node: object | null | undefined,
                                                                                                                  opts?: object | null
                                                                                                              ) => void;

                                                                                                                function assertDeclareOpaqueType

                                                                                                                assertDeclareOpaqueType: (
                                                                                                                    node: object | null | undefined,
                                                                                                                    opts?: object | null
                                                                                                                ) => void;

                                                                                                                  function assertDeclareTypeAlias

                                                                                                                  assertDeclareTypeAlias: (
                                                                                                                      node: object | null | undefined,
                                                                                                                      opts?: object | null
                                                                                                                  ) => void;

                                                                                                                    function assertDeclareVariable

                                                                                                                    assertDeclareVariable: (
                                                                                                                        node: object | null | undefined,
                                                                                                                        opts?: object | null
                                                                                                                    ) => void;

                                                                                                                      function assertDecorator

                                                                                                                      assertDecorator: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                        function assertDirective

                                                                                                                        assertDirective: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                          function assertDirectiveLiteral

                                                                                                                          assertDirectiveLiteral: (
                                                                                                                              node: object | null | undefined,
                                                                                                                              opts?: object | null
                                                                                                                          ) => void;

                                                                                                                            function assertDoExpression

                                                                                                                            assertDoExpression: (
                                                                                                                                node: object | null | undefined,
                                                                                                                                opts?: object | null
                                                                                                                            ) => void;

                                                                                                                              function assertDoWhileStatement

                                                                                                                              assertDoWhileStatement: (
                                                                                                                                  node: object | null | undefined,
                                                                                                                                  opts?: object | null
                                                                                                                              ) => void;

                                                                                                                                function assertEmptyStatement

                                                                                                                                assertEmptyStatement: (
                                                                                                                                    node: object | null | undefined,
                                                                                                                                    opts?: object | null
                                                                                                                                ) => void;

                                                                                                                                  function assertEmptyTypeAnnotation

                                                                                                                                  assertEmptyTypeAnnotation: (
                                                                                                                                      node: object | null | undefined,
                                                                                                                                      opts?: object | null
                                                                                                                                  ) => void;

                                                                                                                                    function assertEnumBody

                                                                                                                                    assertEnumBody: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                      function assertEnumBooleanBody

                                                                                                                                      assertEnumBooleanBody: (
                                                                                                                                          node: object | null | undefined,
                                                                                                                                          opts?: object | null
                                                                                                                                      ) => void;

                                                                                                                                        function assertEnumBooleanMember

                                                                                                                                        assertEnumBooleanMember: (
                                                                                                                                            node: object | null | undefined,
                                                                                                                                            opts?: object | null
                                                                                                                                        ) => void;

                                                                                                                                          function assertEnumDeclaration

                                                                                                                                          assertEnumDeclaration: (
                                                                                                                                              node: object | null | undefined,
                                                                                                                                              opts?: object | null
                                                                                                                                          ) => void;

                                                                                                                                            function assertEnumDefaultedMember

                                                                                                                                            assertEnumDefaultedMember: (
                                                                                                                                                node: object | null | undefined,
                                                                                                                                                opts?: object | null
                                                                                                                                            ) => void;

                                                                                                                                              function assertEnumMember

                                                                                                                                              assertEnumMember: (
                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                  opts?: object | null
                                                                                                                                              ) => void;

                                                                                                                                                function assertEnumNumberBody

                                                                                                                                                assertEnumNumberBody: (
                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                    opts?: object | null
                                                                                                                                                ) => void;

                                                                                                                                                  function assertEnumNumberMember

                                                                                                                                                  assertEnumNumberMember: (
                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                      opts?: object | null
                                                                                                                                                  ) => void;

                                                                                                                                                    function assertEnumStringBody

                                                                                                                                                    assertEnumStringBody: (
                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                        opts?: object | null
                                                                                                                                                    ) => void;

                                                                                                                                                      function assertEnumStringMember

                                                                                                                                                      assertEnumStringMember: (
                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                          opts?: object | null
                                                                                                                                                      ) => void;

                                                                                                                                                        function assertEnumSymbolBody

                                                                                                                                                        assertEnumSymbolBody: (
                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                            opts?: object | null
                                                                                                                                                        ) => void;

                                                                                                                                                          function assertExistsTypeAnnotation

                                                                                                                                                          assertExistsTypeAnnotation: (
                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                              opts?: object | null
                                                                                                                                                          ) => void;

                                                                                                                                                            function assertExportAllDeclaration

                                                                                                                                                            assertExportAllDeclaration: (
                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                opts?: object | null
                                                                                                                                                            ) => void;

                                                                                                                                                              function assertExportDeclaration

                                                                                                                                                              assertExportDeclaration: (
                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                  opts?: object | null
                                                                                                                                                              ) => void;

                                                                                                                                                                function assertExportDefaultDeclaration

                                                                                                                                                                assertExportDefaultDeclaration: (
                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                    opts?: object | null
                                                                                                                                                                ) => void;

                                                                                                                                                                  function assertExportDefaultSpecifier

                                                                                                                                                                  assertExportDefaultSpecifier: (
                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                      opts?: object | null
                                                                                                                                                                  ) => void;

                                                                                                                                                                    function assertExportNamedDeclaration

                                                                                                                                                                    assertExportNamedDeclaration: (
                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                        opts?: object | null
                                                                                                                                                                    ) => void;

                                                                                                                                                                      function assertExportNamespaceSpecifier

                                                                                                                                                                      assertExportNamespaceSpecifier: (
                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                          opts?: object | null
                                                                                                                                                                      ) => void;

                                                                                                                                                                        function assertExportSpecifier

                                                                                                                                                                        assertExportSpecifier: (
                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                            opts?: object | null
                                                                                                                                                                        ) => void;

                                                                                                                                                                          function assertExpression

                                                                                                                                                                          assertExpression: (
                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                              opts?: object | null
                                                                                                                                                                          ) => void;

                                                                                                                                                                            function assertExpressionStatement

                                                                                                                                                                            assertExpressionStatement: (
                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                opts?: object | null
                                                                                                                                                                            ) => void;

                                                                                                                                                                              function assertExpressionWrapper

                                                                                                                                                                              assertExpressionWrapper: (
                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                              ) => void;

                                                                                                                                                                                function assertFile

                                                                                                                                                                                assertFile: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                  function assertFlow

                                                                                                                                                                                  assertFlow: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                    function assertFlowBaseAnnotation

                                                                                                                                                                                    assertFlowBaseAnnotation: (
                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                    ) => void;

                                                                                                                                                                                      function assertFlowDeclaration

                                                                                                                                                                                      assertFlowDeclaration: (
                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                      ) => void;

                                                                                                                                                                                        function assertFlowPredicate

                                                                                                                                                                                        assertFlowPredicate: (
                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                        ) => void;

                                                                                                                                                                                          function assertFlowType

                                                                                                                                                                                          assertFlowType: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                            function assertFor

                                                                                                                                                                                            assertFor: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                              function assertForInStatement

                                                                                                                                                                                              assertForInStatement: (
                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                function assertForOfStatement

                                                                                                                                                                                                assertForOfStatement: (
                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                  function assertForStatement

                                                                                                                                                                                                  assertForStatement: (
                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                    function assertForXStatement

                                                                                                                                                                                                    assertForXStatement: (
                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                      function assertFunction

                                                                                                                                                                                                      assertFunction: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                        function assertFunctionDeclaration

                                                                                                                                                                                                        assertFunctionDeclaration: (
                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                          function assertFunctionExpression

                                                                                                                                                                                                          assertFunctionExpression: (
                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                            function assertFunctionParent

                                                                                                                                                                                                            assertFunctionParent: (
                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                              function assertFunctionTypeAnnotation

                                                                                                                                                                                                              assertFunctionTypeAnnotation: (
                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                function assertFunctionTypeParam

                                                                                                                                                                                                                assertFunctionTypeParam: (
                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                  function assertGenericTypeAnnotation

                                                                                                                                                                                                                  assertGenericTypeAnnotation: (
                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                    function assertIdentifier

                                                                                                                                                                                                                    assertIdentifier: (
                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                      function assertIfStatement

                                                                                                                                                                                                                      assertIfStatement: (
                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                        function assertImmutable

                                                                                                                                                                                                                        assertImmutable: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                          function assertImport

                                                                                                                                                                                                                          assertImport: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                            function assertImportAttribute

                                                                                                                                                                                                                            assertImportAttribute: (
                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                              function assertImportDeclaration

                                                                                                                                                                                                                              assertImportDeclaration: (
                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                function assertImportDefaultSpecifier

                                                                                                                                                                                                                                assertImportDefaultSpecifier: (
                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                  function assertImportNamespaceSpecifier

                                                                                                                                                                                                                                  assertImportNamespaceSpecifier: (
                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                    function assertImportSpecifier

                                                                                                                                                                                                                                    assertImportSpecifier: (
                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                      function assertIndexedAccessType

                                                                                                                                                                                                                                      assertIndexedAccessType: (
                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                        function assertInferredPredicate

                                                                                                                                                                                                                                        assertInferredPredicate: (
                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                          function assertInterfaceDeclaration

                                                                                                                                                                                                                                          assertInterfaceDeclaration: (
                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                            function assertInterfaceExtends

                                                                                                                                                                                                                                            assertInterfaceExtends: (
                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                              function assertInterfaceTypeAnnotation

                                                                                                                                                                                                                                              assertInterfaceTypeAnnotation: (
                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                function assertInterpreterDirective

                                                                                                                                                                                                                                                assertInterpreterDirective: (
                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                  function assertIntersectionTypeAnnotation

                                                                                                                                                                                                                                                  assertIntersectionTypeAnnotation: (
                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                    function assertJSX

                                                                                                                                                                                                                                                    assertJSX: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                      function assertJSXAttribute

                                                                                                                                                                                                                                                      assertJSXAttribute: (
                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                        function assertJSXClosingElement

                                                                                                                                                                                                                                                        assertJSXClosingElement: (
                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                          function assertJSXClosingFragment

                                                                                                                                                                                                                                                          assertJSXClosingFragment: (
                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                            function assertJSXElement

                                                                                                                                                                                                                                                            assertJSXElement: (
                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                              function assertJSXEmptyExpression

                                                                                                                                                                                                                                                              assertJSXEmptyExpression: (
                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                function assertJSXExpressionContainer

                                                                                                                                                                                                                                                                assertJSXExpressionContainer: (
                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                  function assertJSXFragment

                                                                                                                                                                                                                                                                  assertJSXFragment: (
                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                    function assertJSXIdentifier

                                                                                                                                                                                                                                                                    assertJSXIdentifier: (
                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                      function assertJSXMemberExpression

                                                                                                                                                                                                                                                                      assertJSXMemberExpression: (
                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                        function assertJSXNamespacedName

                                                                                                                                                                                                                                                                        assertJSXNamespacedName: (
                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                          function assertJSXOpeningElement

                                                                                                                                                                                                                                                                          assertJSXOpeningElement: (
                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                            function assertJSXOpeningFragment

                                                                                                                                                                                                                                                                            assertJSXOpeningFragment: (
                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                              function assertJSXSpreadAttribute

                                                                                                                                                                                                                                                                              assertJSXSpreadAttribute: (
                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                function assertJSXSpreadChild

                                                                                                                                                                                                                                                                                assertJSXSpreadChild: (
                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                  function assertJSXText

                                                                                                                                                                                                                                                                                  assertJSXText: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                    function assertLabeledStatement

                                                                                                                                                                                                                                                                                    assertLabeledStatement: (
                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                      function assertLiteral

                                                                                                                                                                                                                                                                                      assertLiteral: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                        function assertLogicalExpression

                                                                                                                                                                                                                                                                                        assertLogicalExpression: (
                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                          function assertLoop

                                                                                                                                                                                                                                                                                          assertLoop: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                            function assertLVal

                                                                                                                                                                                                                                                                                            assertLVal: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                              function assertMemberExpression

                                                                                                                                                                                                                                                                                              assertMemberExpression: (
                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                function assertMetaProperty

                                                                                                                                                                                                                                                                                                assertMetaProperty: (
                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                  function assertMethod

                                                                                                                                                                                                                                                                                                  assertMethod: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                    function assertMixedTypeAnnotation

                                                                                                                                                                                                                                                                                                    assertMixedTypeAnnotation: (
                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                      function assertModuleDeclaration

                                                                                                                                                                                                                                                                                                      assertModuleDeclaration: (
                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                        function assertModuleExpression

                                                                                                                                                                                                                                                                                                        assertModuleExpression: (
                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                          function assertModuleSpecifier

                                                                                                                                                                                                                                                                                                          assertModuleSpecifier: (
                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                            function assertNewExpression

                                                                                                                                                                                                                                                                                                            assertNewExpression: (
                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                              function assertNode

                                                                                                                                                                                                                                                                                                              assertNode: (obj: any) => void;

                                                                                                                                                                                                                                                                                                                function assertNoop

                                                                                                                                                                                                                                                                                                                assertNoop: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                  function assertNullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                  assertNullableTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                    function assertNullLiteral

                                                                                                                                                                                                                                                                                                                    assertNullLiteral: (
                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                      function assertNullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                      assertNullLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                        function assertNumberLiteral

                                                                                                                                                                                                                                                                                                                        assertNumberLiteral: (
                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                          Use assertNumericLiteral

                                                                                                                                                                                                                                                                                                                        function assertNumberLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                        assertNumberLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                          function assertNumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                          assertNumberTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                            function assertNumericLiteral

                                                                                                                                                                                                                                                                                                                            assertNumericLiteral: (
                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                              function assertObjectExpression

                                                                                                                                                                                                                                                                                                                              assertObjectExpression: (
                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                function assertObjectMember

                                                                                                                                                                                                                                                                                                                                assertObjectMember: (
                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                  function assertObjectMethod

                                                                                                                                                                                                                                                                                                                                  assertObjectMethod: (
                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                    function assertObjectPattern

                                                                                                                                                                                                                                                                                                                                    assertObjectPattern: (
                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                      function assertObjectProperty

                                                                                                                                                                                                                                                                                                                                      assertObjectProperty: (
                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                        function assertObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                        assertObjectTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                          function assertObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                          assertObjectTypeCallProperty: (
                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                            function assertObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                            assertObjectTypeIndexer: (
                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                              function assertObjectTypeInternalSlot

                                                                                                                                                                                                                                                                                                                                              assertObjectTypeInternalSlot: (
                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                function assertObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                                assertObjectTypeProperty: (
                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                  function assertObjectTypeSpreadProperty

                                                                                                                                                                                                                                                                                                                                                  assertObjectTypeSpreadProperty: (
                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                    function assertOpaqueType

                                                                                                                                                                                                                                                                                                                                                    assertOpaqueType: (
                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                      function assertOptionalCallExpression

                                                                                                                                                                                                                                                                                                                                                      assertOptionalCallExpression: (
                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                        function assertOptionalIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                        assertOptionalIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                          function assertOptionalMemberExpression

                                                                                                                                                                                                                                                                                                                                                          assertOptionalMemberExpression: (
                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                            function assertParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                            assertParenthesizedExpression: (
                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                              function assertPattern

                                                                                                                                                                                                                                                                                                                                                              assertPattern: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                function assertPatternLike

                                                                                                                                                                                                                                                                                                                                                                assertPatternLike: (
                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                  function assertPipelineBareFunction

                                                                                                                                                                                                                                                                                                                                                                  assertPipelineBareFunction: (
                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                    function assertPipelinePrimaryTopicReference

                                                                                                                                                                                                                                                                                                                                                                    assertPipelinePrimaryTopicReference: (
                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                      function assertPipelineTopicExpression

                                                                                                                                                                                                                                                                                                                                                                      assertPipelineTopicExpression: (
                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                        function assertPlaceholder

                                                                                                                                                                                                                                                                                                                                                                        assertPlaceholder: (
                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                          function assertPrivate

                                                                                                                                                                                                                                                                                                                                                                          assertPrivate: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                            function assertPrivateName

                                                                                                                                                                                                                                                                                                                                                                            assertPrivateName: (
                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                              function assertProgram

                                                                                                                                                                                                                                                                                                                                                                              assertProgram: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                function assertProperty

                                                                                                                                                                                                                                                                                                                                                                                assertProperty: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                  function assertPureish

                                                                                                                                                                                                                                                                                                                                                                                  assertPureish: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                    function assertQualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                                    assertQualifiedTypeIdentifier: (
                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                      function assertRecordExpression

                                                                                                                                                                                                                                                                                                                                                                                      assertRecordExpression: (
                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                        function assertRegexLiteral

                                                                                                                                                                                                                                                                                                                                                                                        assertRegexLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                        • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                          Use assertRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                        function assertRegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                        assertRegExpLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                          function assertRestElement

                                                                                                                                                                                                                                                                                                                                                                                          assertRestElement: (
                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                            function assertRestProperty

                                                                                                                                                                                                                                                                                                                                                                                            assertRestProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                            • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                              Use assertRestElement

                                                                                                                                                                                                                                                                                                                                                                                            function assertReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                            assertReturnStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                              function assertScopable

                                                                                                                                                                                                                                                                                                                                                                                              assertScopable: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                function assertSequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                assertSequenceExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                  function assertSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                  assertSpreadElement: (
                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    function assertSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                    assertSpreadProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                    • Deprecated

                                                                                                                                                                                                                                                                                                                                                                                                      Use assertSpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                    function assertStatement

                                                                                                                                                                                                                                                                                                                                                                                                    assertStatement: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                      function assertStaticBlock

                                                                                                                                                                                                                                                                                                                                                                                                      assertStaticBlock: (
                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                        function assertStringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                        assertStringLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                          function assertStringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                          assertStringLiteralTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                            function assertStringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                            assertStringTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                              function assertSuper

                                                                                                                                                                                                                                                                                                                                                                                                              assertSuper: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                function assertSwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                assertSwitchCase: (
                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                  function assertSwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                  assertSwitchStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                    function assertSymbolTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                    assertSymbolTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                      assertTaggedTemplateExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                        assertTemplateElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                          assertTemplateLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTerminatorless

                                                                                                                                                                                                                                                                                                                                                                                                                            assertTerminatorless: (
                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                              function assertThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                              assertThisExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                function assertThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                assertThisTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                  assertThrowStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTryStatement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSAnyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSAnyKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSArrayType

                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSArrayType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSAsExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSAsExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSBaseType

                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSBaseType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSBigIntKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSBigIntKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSBooleanKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSCallSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSConditionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSConditionalType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSConstructorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSConstructorType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSConstructSignatureDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSDeclareFunction: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSDeclareMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSDeclareMethod: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSEntityName

                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSEntityName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSEnumDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSEnumMember: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSExportAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSExportAssignment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSExpressionWithTypeArguments: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSExternalModuleReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSFunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSFunctionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSImportEqualsDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSImportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSImportType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSIndexedAccessType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSIndexSignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSInferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSInferType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSInterfaceBody: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSInterfaceDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSIntersectionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSIntrinsicKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSIntrinsicKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSLiteralType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSMappedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSMappedType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSMethodSignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSModuleBlock: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSModuleDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSNamedTupleMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSNamedTupleMember: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSNamespaceExportDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSNeverKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSNonNullExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSNullKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSNumberKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSObjectKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSOptionalType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSParameterProperty: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSParenthesizedType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSPropertySignature: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSQualifiedName: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSRestType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSStringKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSSymbolKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSThisType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSTupleType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSType: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSTypeAliasDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTypeAssertion: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSTypeElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSTypeElement: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSTypeLiteral: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSTypeOperator: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTSTypeParameterInstantiation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTSTypePredicate: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTSTypeQuery: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTSTypeReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTSUndefinedKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTSUnionType: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTSUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTSUnknownKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTSVoidKeyword: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTupleExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTupleExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              function assertTupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              assertTupleTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                function assertTypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                assertTypeAlias: (node: object | null | undefined, opts?: object | null) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  function assertTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  assertTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    function assertTypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTypeCastExpression: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      function assertTypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      assertTypeofTypeAnnotation: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        function assertTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        assertTypeParameter: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          function assertTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          assertTypeParameterDeclaration: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              node: object | null | undefined,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              opts?: object | null
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            function assertTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            assertTypeParameterInstantiation: (