@babel/types

  • Version 7.17.0
  • Published
  • 1.03 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 assertAccessor

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

                      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 assertClassAccessorProperty

                                                                    assertClassAccessorProperty: (
                                                                    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 assertMiscellaneous

                                                                                                                                                                                                                                                                                                        assertMiscellaneous: (
                                                                                                                                                                                                                                                                                                        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 assertStandardized

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

                                                                                                                                                                                                                                                                                                                                                                                                            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