jsDocs.io logo

@babel/types

  • Version 7.15.0
  • Published
  • 1.01 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 assertTopicReference

                                                                                                                                                                                                                                                                                                                                                                                                                                    assertTopicReference: (
                                                                                                                                                                                                                                                                                                                                                                                                                                        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