@types/jscodeshift

  • Version 0.11.5
  • Published
  • 38.2 kB
  • 2 dependencies
  • MIT license

Install

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

Overview

TypeScript definitions for jscodeshift

Index

Variables

Interfaces

Type Aliases

Variables

variable core

const core: any;

    Interfaces

    interface API

    interface API {}

      property j

      j: JSCodeshift;

        property jscodeshift

        jscodeshift: JSCodeshift;

          property report

          report: (msg: string) => void;

            property stats

            stats: Stats;

              interface Core

              interface Core {}

                property filters

                filters: Filters;

                  property mappings

                  mappings: Mappings;

                    property registerMethods

                    registerMethods: typeof Collection.registerMethods;

                      property template

                      template: template.Template;
                      • template, bound to default parser

                      property types

                      types: typeof recast.types;

                        method match

                        match: (path: ASTNode | ASTPath, filter: any) => boolean;

                          method use

                          use: (plugin: Plugin) => void;
                          • Utility function for registering plugins.

                            Plugins are simple functions that are passed the core jscodeshift instance. They should extend jscodeshift by calling registerMethods, etc. This method guards against repeated registrations (the plugin callback will only be called once).

                          method withParser

                          withParser: (parser: string | Parser) => JSCodeshift;
                          • Returns a version of the core jscodeshift function "bound" to a specific parser.

                          call signature

                          (source: string, options?: Options): Collection.Collection<any>;

                            call signature

                            (source: ASTNode | ASTNode[] | ASTPath | ASTPath[]): Collection.Collection<any>;

                              interface FileInfo

                              interface FileInfo {}

                                property path

                                path: string;
                                • The path to the current file.

                                property source

                                source: string;
                                • The source code of the current file.

                                interface Filters

                                interface Filters {}

                                  property JSXElement

                                  JSXElement: JSXElement.FilterMethods;

                                    property VariableDeclarator

                                    VariableDeclarator: VariableDeclarator.FilterMethods;

                                      interface Mappings

                                      interface Mappings {}

                                        property JSXElement

                                        JSXElement: JSXElement.MappingMethods;

                                          interface Options

                                          interface Options {}

                                            index signature

                                            [option: string]: any;

                                              interface Parser

                                              interface Parser {}

                                                method parse

                                                parse: (source: string, options?: any) => types.ASTNode;

                                                  interface Plugin

                                                  interface Plugin {}

                                                    call signature

                                                    (core: Core): void;

                                                      interface Stats

                                                      interface Stats {}

                                                        call signature

                                                        (name: string, quantity?: number): void;
                                                        • Helper function to collect data during --dry runs. This function keeps a counter for how often it was called with a specific argument. The result is shown in the console. Useful for finding out how many files match a criterion.

                                                        interface Transform

                                                        interface Transform {}

                                                          call signature

                                                          (file: FileInfo, api: API, options: Options): string | null | undefined | void;
                                                          • If a string is returned and it is different from passed source, the transform is considered to be successful. If a string is returned but it's the same as the source, the transform is considered to be unsuccessful. If nothing is returned, the file is not supposed to be transformed (which is ok).

                                                          Type Aliases

                                                          type AnyTypeAnnotation

                                                          type AnyTypeAnnotation = astTypes.namedTypes.AnyTypeAnnotation;

                                                            type ArrayExpression

                                                            type ArrayExpression = astTypes.namedTypes.ArrayExpression;

                                                              type ArrayPattern

                                                              type ArrayPattern = astTypes.namedTypes.ArrayPattern;

                                                                type ArrayTypeAnnotation

                                                                type ArrayTypeAnnotation = astTypes.namedTypes.ArrayTypeAnnotation;

                                                                  type ArrowFunctionExpression

                                                                  type ArrowFunctionExpression = astTypes.namedTypes.ArrowFunctionExpression;

                                                                    type AssignmentExpression

                                                                    type AssignmentExpression = astTypes.namedTypes.AssignmentExpression;

                                                                      type AssignmentPattern

                                                                      type AssignmentPattern = astTypes.namedTypes.AssignmentPattern;

                                                                        type ASTNode

                                                                        type ASTNode = astTypes.namedTypes.ASTNode;

                                                                          type ASTPath

                                                                          type ASTPath<N = ASTNode> = nodePath.NodePath<N, N>;

                                                                            type AwaitExpression

                                                                            type AwaitExpression = astTypes.namedTypes.AwaitExpression;

                                                                              type BigIntLiteral

                                                                              type BigIntLiteral = astTypes.namedTypes.BigIntLiteral;

                                                                                type BigIntLiteralTypeAnnotation

                                                                                type BigIntLiteralTypeAnnotation = astTypes.namedTypes.BigIntLiteralTypeAnnotation;

                                                                                  type BigIntTypeAnnotation

                                                                                  type BigIntTypeAnnotation = astTypes.namedTypes.BigIntTypeAnnotation;

                                                                                    type BinaryExpression

                                                                                    type BinaryExpression = astTypes.namedTypes.BinaryExpression;

                                                                                      type BindExpression

                                                                                      type BindExpression = astTypes.namedTypes.BindExpression;

                                                                                        type Block

                                                                                        type Block = astTypes.namedTypes.Block;

                                                                                          type BlockStatement

                                                                                          type BlockStatement = astTypes.namedTypes.BlockStatement;

                                                                                            type BooleanLiteral

                                                                                            type BooleanLiteral = astTypes.namedTypes.BooleanLiteral;

                                                                                              type BooleanLiteralTypeAnnotation

                                                                                              type BooleanLiteralTypeAnnotation = astTypes.namedTypes.BooleanLiteralTypeAnnotation;

                                                                                                type BooleanTypeAnnotation

                                                                                                type BooleanTypeAnnotation = astTypes.namedTypes.BooleanTypeAnnotation;

                                                                                                  type BreakStatement

                                                                                                  type BreakStatement = astTypes.namedTypes.BreakStatement;

                                                                                                    type CallExpression

                                                                                                    type CallExpression = astTypes.namedTypes.CallExpression;

                                                                                                      type CatchClause

                                                                                                      type CatchClause = astTypes.namedTypes.CatchClause;

                                                                                                        type ChainElement

                                                                                                        type ChainElement = astTypes.namedTypes.ChainElement;

                                                                                                          type ChainExpression

                                                                                                          type ChainExpression = astTypes.namedTypes.ChainExpression;

                                                                                                            type ClassBody

                                                                                                            type ClassBody = astTypes.namedTypes.ClassBody;

                                                                                                              type ClassDeclaration

                                                                                                              type ClassDeclaration = astTypes.namedTypes.ClassDeclaration;

                                                                                                                type ClassExpression

                                                                                                                type ClassExpression = astTypes.namedTypes.ClassExpression;

                                                                                                                  type ClassImplements

                                                                                                                  type ClassImplements = astTypes.namedTypes.ClassImplements;

                                                                                                                    type ClassMethod

                                                                                                                    type ClassMethod = astTypes.namedTypes.ClassMethod;

                                                                                                                      type ClassPrivateMethod

                                                                                                                      type ClassPrivateMethod = astTypes.namedTypes.ClassPrivateMethod;

                                                                                                                        type ClassPrivateProperty

                                                                                                                        type ClassPrivateProperty = astTypes.namedTypes.ClassPrivateProperty;

                                                                                                                          type ClassProperty

                                                                                                                          type ClassProperty = astTypes.namedTypes.ClassProperty;

                                                                                                                            type ClassPropertyDefinition

                                                                                                                            type ClassPropertyDefinition = astTypes.namedTypes.ClassPropertyDefinition;

                                                                                                                              type Collection

                                                                                                                              type Collection<T = any> = Collection.Collection<T>;

                                                                                                                                type Comment

                                                                                                                                type Comment = astTypes.namedTypes.Comment;

                                                                                                                                  type CommentBlock

                                                                                                                                  type CommentBlock = astTypes.namedTypes.CommentBlock;

                                                                                                                                    type CommentLine

                                                                                                                                    type CommentLine = astTypes.namedTypes.CommentLine;

                                                                                                                                      type ComprehensionBlock

                                                                                                                                      type ComprehensionBlock = astTypes.namedTypes.ComprehensionBlock;

                                                                                                                                        type ComprehensionExpression

                                                                                                                                        type ComprehensionExpression = astTypes.namedTypes.ComprehensionExpression;

                                                                                                                                          type ConditionalExpression

                                                                                                                                          type ConditionalExpression = astTypes.namedTypes.ConditionalExpression;

                                                                                                                                            type ContinueStatement

                                                                                                                                            type ContinueStatement = astTypes.namedTypes.ContinueStatement;

                                                                                                                                              type DebuggerStatement

                                                                                                                                              type DebuggerStatement = astTypes.namedTypes.DebuggerStatement;

                                                                                                                                                type Declaration

                                                                                                                                                type Declaration = astTypes.namedTypes.Declaration;

                                                                                                                                                  type DeclareClass

                                                                                                                                                  type DeclareClass = astTypes.namedTypes.DeclareClass;

                                                                                                                                                    type DeclaredPredicate

                                                                                                                                                    type DeclaredPredicate = astTypes.namedTypes.DeclaredPredicate;

                                                                                                                                                      type DeclareExportAllDeclaration

                                                                                                                                                      type DeclareExportAllDeclaration = astTypes.namedTypes.DeclareExportAllDeclaration;

                                                                                                                                                        type DeclareExportDeclaration

                                                                                                                                                        type DeclareExportDeclaration = astTypes.namedTypes.DeclareExportDeclaration;

                                                                                                                                                          type DeclareFunction

                                                                                                                                                          type DeclareFunction = astTypes.namedTypes.DeclareFunction;

                                                                                                                                                            type DeclareInterface

                                                                                                                                                            type DeclareInterface = astTypes.namedTypes.DeclareInterface;

                                                                                                                                                              type DeclareModule

                                                                                                                                                              type DeclareModule = astTypes.namedTypes.DeclareModule;

                                                                                                                                                                type DeclareModuleExports

                                                                                                                                                                type DeclareModuleExports = astTypes.namedTypes.DeclareModuleExports;

                                                                                                                                                                  type DeclareOpaqueType

                                                                                                                                                                  type DeclareOpaqueType = astTypes.namedTypes.DeclareOpaqueType;

                                                                                                                                                                    type DeclareTypeAlias

                                                                                                                                                                    type DeclareTypeAlias = astTypes.namedTypes.DeclareTypeAlias;

                                                                                                                                                                      type DeclareVariable

                                                                                                                                                                      type DeclareVariable = astTypes.namedTypes.DeclareVariable;

                                                                                                                                                                        type Decorator

                                                                                                                                                                        type Decorator = astTypes.namedTypes.Decorator;

                                                                                                                                                                          type Directive

                                                                                                                                                                          type Directive = astTypes.namedTypes.Directive;

                                                                                                                                                                            type DirectiveLiteral

                                                                                                                                                                            type DirectiveLiteral = astTypes.namedTypes.DirectiveLiteral;

                                                                                                                                                                              type DoExpression

                                                                                                                                                                              type DoExpression = astTypes.namedTypes.DoExpression;

                                                                                                                                                                                type DoWhileStatement

                                                                                                                                                                                type DoWhileStatement = astTypes.namedTypes.DoWhileStatement;

                                                                                                                                                                                  type EmptyStatement

                                                                                                                                                                                  type EmptyStatement = astTypes.namedTypes.EmptyStatement;

                                                                                                                                                                                    type EmptyTypeAnnotation

                                                                                                                                                                                    type EmptyTypeAnnotation = astTypes.namedTypes.EmptyTypeAnnotation;

                                                                                                                                                                                      type EnumBooleanBody

                                                                                                                                                                                      type EnumBooleanBody = astTypes.namedTypes.EnumBooleanBody;

                                                                                                                                                                                        type EnumBooleanMember

                                                                                                                                                                                        type EnumBooleanMember = astTypes.namedTypes.EnumBooleanMember;

                                                                                                                                                                                          type EnumDeclaration

                                                                                                                                                                                          type EnumDeclaration = astTypes.namedTypes.EnumDeclaration;

                                                                                                                                                                                            type EnumDefaultedMember

                                                                                                                                                                                            type EnumDefaultedMember = astTypes.namedTypes.EnumDefaultedMember;

                                                                                                                                                                                              type EnumNumberBody

                                                                                                                                                                                              type EnumNumberBody = astTypes.namedTypes.EnumNumberBody;

                                                                                                                                                                                                type EnumNumberMember

                                                                                                                                                                                                type EnumNumberMember = astTypes.namedTypes.EnumNumberMember;

                                                                                                                                                                                                  type EnumStringBody

                                                                                                                                                                                                  type EnumStringBody = astTypes.namedTypes.EnumStringBody;

                                                                                                                                                                                                    type EnumStringMember

                                                                                                                                                                                                    type EnumStringMember = astTypes.namedTypes.EnumStringMember;

                                                                                                                                                                                                      type EnumSymbolBody

                                                                                                                                                                                                      type EnumSymbolBody = astTypes.namedTypes.EnumSymbolBody;

                                                                                                                                                                                                        type ExistentialTypeParam

                                                                                                                                                                                                        type ExistentialTypeParam = astTypes.namedTypes.ExistentialTypeParam;

                                                                                                                                                                                                          type ExistsTypeAnnotation

                                                                                                                                                                                                          type ExistsTypeAnnotation = astTypes.namedTypes.ExistsTypeAnnotation;

                                                                                                                                                                                                            type ExportAllDeclaration

                                                                                                                                                                                                            type ExportAllDeclaration = astTypes.namedTypes.ExportAllDeclaration;

                                                                                                                                                                                                              type ExportBatchSpecifier

                                                                                                                                                                                                              type ExportBatchSpecifier = astTypes.namedTypes.ExportBatchSpecifier;

                                                                                                                                                                                                                type ExportDeclaration

                                                                                                                                                                                                                type ExportDeclaration = astTypes.namedTypes.ExportDeclaration;

                                                                                                                                                                                                                  type ExportDefaultDeclaration

                                                                                                                                                                                                                  type ExportDefaultDeclaration = astTypes.namedTypes.ExportDefaultDeclaration;

                                                                                                                                                                                                                    type ExportDefaultSpecifier

                                                                                                                                                                                                                    type ExportDefaultSpecifier = astTypes.namedTypes.ExportDefaultSpecifier;

                                                                                                                                                                                                                      type ExportNamedDeclaration

                                                                                                                                                                                                                      type ExportNamedDeclaration = astTypes.namedTypes.ExportNamedDeclaration;

                                                                                                                                                                                                                        type ExportNamespaceSpecifier

                                                                                                                                                                                                                        type ExportNamespaceSpecifier = astTypes.namedTypes.ExportNamespaceSpecifier;

                                                                                                                                                                                                                          type ExportSpecifier

                                                                                                                                                                                                                          type ExportSpecifier = astTypes.namedTypes.ExportSpecifier;

                                                                                                                                                                                                                            type Expression

                                                                                                                                                                                                                            type Expression = astTypes.namedTypes.Expression;

                                                                                                                                                                                                                              type ExpressionStatement

                                                                                                                                                                                                                              type ExpressionStatement = astTypes.namedTypes.ExpressionStatement;

                                                                                                                                                                                                                                type File

                                                                                                                                                                                                                                type File = astTypes.namedTypes.File;

                                                                                                                                                                                                                                  type Flow

                                                                                                                                                                                                                                  type Flow = astTypes.namedTypes.Flow;

                                                                                                                                                                                                                                    type FlowPredicate

                                                                                                                                                                                                                                    type FlowPredicate = astTypes.namedTypes.FlowPredicate;

                                                                                                                                                                                                                                      type FlowType

                                                                                                                                                                                                                                      type FlowType = astTypes.namedTypes.FlowType;

                                                                                                                                                                                                                                        type ForAwaitStatement

                                                                                                                                                                                                                                        type ForAwaitStatement = astTypes.namedTypes.ForAwaitStatement;

                                                                                                                                                                                                                                          type ForInStatement

                                                                                                                                                                                                                                          type ForInStatement = astTypes.namedTypes.ForInStatement;

                                                                                                                                                                                                                                            type ForOfStatement

                                                                                                                                                                                                                                            type ForOfStatement = astTypes.namedTypes.ForOfStatement;

                                                                                                                                                                                                                                              type ForStatement

                                                                                                                                                                                                                                              type ForStatement = astTypes.namedTypes.ForStatement;

                                                                                                                                                                                                                                                type Function

                                                                                                                                                                                                                                                type Function = astTypes.namedTypes.Function;

                                                                                                                                                                                                                                                  type FunctionDeclaration

                                                                                                                                                                                                                                                  type FunctionDeclaration = astTypes.namedTypes.FunctionDeclaration;

                                                                                                                                                                                                                                                    type FunctionExpression

                                                                                                                                                                                                                                                    type FunctionExpression = astTypes.namedTypes.FunctionExpression;

                                                                                                                                                                                                                                                      type FunctionTypeAnnotation

                                                                                                                                                                                                                                                      type FunctionTypeAnnotation = astTypes.namedTypes.FunctionTypeAnnotation;

                                                                                                                                                                                                                                                        type FunctionTypeParam

                                                                                                                                                                                                                                                        type FunctionTypeParam = astTypes.namedTypes.FunctionTypeParam;

                                                                                                                                                                                                                                                          type GeneratorExpression

                                                                                                                                                                                                                                                          type GeneratorExpression = astTypes.namedTypes.GeneratorExpression;

                                                                                                                                                                                                                                                            type GenericTypeAnnotation

                                                                                                                                                                                                                                                            type GenericTypeAnnotation = astTypes.namedTypes.GenericTypeAnnotation;

                                                                                                                                                                                                                                                              type Identifier

                                                                                                                                                                                                                                                              type Identifier = astTypes.namedTypes.Identifier;

                                                                                                                                                                                                                                                                type IfStatement

                                                                                                                                                                                                                                                                type IfStatement = astTypes.namedTypes.IfStatement;

                                                                                                                                                                                                                                                                  type Import

                                                                                                                                                                                                                                                                  type Import = astTypes.namedTypes.Import;

                                                                                                                                                                                                                                                                    type ImportDeclaration

                                                                                                                                                                                                                                                                    type ImportDeclaration = astTypes.namedTypes.ImportDeclaration;

                                                                                                                                                                                                                                                                      type ImportDefaultSpecifier

                                                                                                                                                                                                                                                                      type ImportDefaultSpecifier = astTypes.namedTypes.ImportDefaultSpecifier;

                                                                                                                                                                                                                                                                        type ImportExpression

                                                                                                                                                                                                                                                                        type ImportExpression = astTypes.namedTypes.ImportExpression;

                                                                                                                                                                                                                                                                          type ImportNamespaceSpecifier

                                                                                                                                                                                                                                                                          type ImportNamespaceSpecifier = astTypes.namedTypes.ImportNamespaceSpecifier;

                                                                                                                                                                                                                                                                            type ImportSpecifier

                                                                                                                                                                                                                                                                            type ImportSpecifier = astTypes.namedTypes.ImportSpecifier;

                                                                                                                                                                                                                                                                              type InferredPredicate

                                                                                                                                                                                                                                                                              type InferredPredicate = astTypes.namedTypes.InferredPredicate;

                                                                                                                                                                                                                                                                                type InterfaceDeclaration

                                                                                                                                                                                                                                                                                type InterfaceDeclaration = astTypes.namedTypes.InterfaceDeclaration;

                                                                                                                                                                                                                                                                                  type InterfaceExtends

                                                                                                                                                                                                                                                                                  type InterfaceExtends = astTypes.namedTypes.InterfaceExtends;

                                                                                                                                                                                                                                                                                    type InterfaceTypeAnnotation

                                                                                                                                                                                                                                                                                    type InterfaceTypeAnnotation = astTypes.namedTypes.InterfaceTypeAnnotation;

                                                                                                                                                                                                                                                                                      type InterpreterDirective

                                                                                                                                                                                                                                                                                      type InterpreterDirective = astTypes.namedTypes.InterpreterDirective;

                                                                                                                                                                                                                                                                                        type IntersectionTypeAnnotation

                                                                                                                                                                                                                                                                                        type IntersectionTypeAnnotation = astTypes.namedTypes.IntersectionTypeAnnotation;

                                                                                                                                                                                                                                                                                          type JSCodeshift

                                                                                                                                                                                                                                                                                          type JSCodeshift = Core &
                                                                                                                                                                                                                                                                                          typeof recast.types.namedTypes &
                                                                                                                                                                                                                                                                                          typeof recast.types.builders;

                                                                                                                                                                                                                                                                                            type JSXAttribute

                                                                                                                                                                                                                                                                                            type JSXAttribute = astTypes.namedTypes.JSXAttribute;

                                                                                                                                                                                                                                                                                              type JSXClosingElement

                                                                                                                                                                                                                                                                                              type JSXClosingElement = astTypes.namedTypes.JSXClosingElement;

                                                                                                                                                                                                                                                                                                type JSXClosingFragment

                                                                                                                                                                                                                                                                                                type JSXClosingFragment = astTypes.namedTypes.JSXClosingFragment;

                                                                                                                                                                                                                                                                                                  type JSXElement

                                                                                                                                                                                                                                                                                                  type JSXElement = astTypes.namedTypes.JSXElement;

                                                                                                                                                                                                                                                                                                    type JSXEmptyExpression

                                                                                                                                                                                                                                                                                                    type JSXEmptyExpression = astTypes.namedTypes.JSXEmptyExpression;

                                                                                                                                                                                                                                                                                                      type JSXExpressionContainer

                                                                                                                                                                                                                                                                                                      type JSXExpressionContainer = astTypes.namedTypes.JSXExpressionContainer;

                                                                                                                                                                                                                                                                                                        type JSXFragment

                                                                                                                                                                                                                                                                                                        type JSXFragment = astTypes.namedTypes.JSXFragment;

                                                                                                                                                                                                                                                                                                          type JSXIdentifier

                                                                                                                                                                                                                                                                                                          type JSXIdentifier = astTypes.namedTypes.JSXIdentifier;

                                                                                                                                                                                                                                                                                                            type JSXMemberExpression

                                                                                                                                                                                                                                                                                                            type JSXMemberExpression = astTypes.namedTypes.JSXMemberExpression;

                                                                                                                                                                                                                                                                                                              type JSXNamespacedName

                                                                                                                                                                                                                                                                                                              type JSXNamespacedName = astTypes.namedTypes.JSXNamespacedName;

                                                                                                                                                                                                                                                                                                                type JSXOpeningElement

                                                                                                                                                                                                                                                                                                                type JSXOpeningElement = astTypes.namedTypes.JSXOpeningElement;

                                                                                                                                                                                                                                                                                                                  type JSXOpeningFragment

                                                                                                                                                                                                                                                                                                                  type JSXOpeningFragment = astTypes.namedTypes.JSXOpeningFragment;

                                                                                                                                                                                                                                                                                                                    type JSXSpreadAttribute

                                                                                                                                                                                                                                                                                                                    type JSXSpreadAttribute = astTypes.namedTypes.JSXSpreadAttribute;

                                                                                                                                                                                                                                                                                                                      type JSXSpreadChild

                                                                                                                                                                                                                                                                                                                      type JSXSpreadChild = astTypes.namedTypes.JSXSpreadChild;

                                                                                                                                                                                                                                                                                                                        type JSXText

                                                                                                                                                                                                                                                                                                                        type JSXText = astTypes.namedTypes.JSXText;

                                                                                                                                                                                                                                                                                                                          type LabeledStatement

                                                                                                                                                                                                                                                                                                                          type LabeledStatement = astTypes.namedTypes.LabeledStatement;

                                                                                                                                                                                                                                                                                                                            type Line

                                                                                                                                                                                                                                                                                                                            type Line = astTypes.namedTypes.Line;

                                                                                                                                                                                                                                                                                                                              type Literal

                                                                                                                                                                                                                                                                                                                              type Literal = astTypes.namedTypes.Literal;

                                                                                                                                                                                                                                                                                                                                type LogicalExpression

                                                                                                                                                                                                                                                                                                                                type LogicalExpression = astTypes.namedTypes.LogicalExpression;

                                                                                                                                                                                                                                                                                                                                  type MemberExpression

                                                                                                                                                                                                                                                                                                                                  type MemberExpression = astTypes.namedTypes.MemberExpression;

                                                                                                                                                                                                                                                                                                                                    type MemberTypeAnnotation

                                                                                                                                                                                                                                                                                                                                    type MemberTypeAnnotation = astTypes.namedTypes.MemberTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                      type MetaProperty

                                                                                                                                                                                                                                                                                                                                      type MetaProperty = astTypes.namedTypes.MetaProperty;

                                                                                                                                                                                                                                                                                                                                        type MethodDefinition

                                                                                                                                                                                                                                                                                                                                        type MethodDefinition = astTypes.namedTypes.MethodDefinition;

                                                                                                                                                                                                                                                                                                                                          type MixedTypeAnnotation

                                                                                                                                                                                                                                                                                                                                          type MixedTypeAnnotation = astTypes.namedTypes.MixedTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                            type ModuleSpecifier

                                                                                                                                                                                                                                                                                                                                            type ModuleSpecifier = astTypes.namedTypes.ModuleSpecifier;

                                                                                                                                                                                                                                                                                                                                              type NewExpression

                                                                                                                                                                                                                                                                                                                                              type NewExpression = astTypes.namedTypes.NewExpression;

                                                                                                                                                                                                                                                                                                                                                type Node

                                                                                                                                                                                                                                                                                                                                                type Node = astTypes.namedTypes.Node;

                                                                                                                                                                                                                                                                                                                                                  type Noop

                                                                                                                                                                                                                                                                                                                                                  type Noop = astTypes.namedTypes.Noop;

                                                                                                                                                                                                                                                                                                                                                    type NullableTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                    type NullableTypeAnnotation = astTypes.namedTypes.NullableTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                      type NullLiteral

                                                                                                                                                                                                                                                                                                                                                      type NullLiteral = astTypes.namedTypes.NullLiteral;

                                                                                                                                                                                                                                                                                                                                                        type NullLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                        type NullLiteralTypeAnnotation = astTypes.namedTypes.NullLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                          type NullTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                          type NullTypeAnnotation = astTypes.namedTypes.NullTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                            type NumberLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                            type NumberLiteralTypeAnnotation = astTypes.namedTypes.NumberLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                              type NumberTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                              type NumberTypeAnnotation = astTypes.namedTypes.NumberTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                type NumericLiteral

                                                                                                                                                                                                                                                                                                                                                                type NumericLiteral = astTypes.namedTypes.NumericLiteral;

                                                                                                                                                                                                                                                                                                                                                                  type NumericLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                  type NumericLiteralTypeAnnotation = astTypes.namedTypes.NumericLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                    type ObjectExpression

                                                                                                                                                                                                                                                                                                                                                                    type ObjectExpression = astTypes.namedTypes.ObjectExpression;

                                                                                                                                                                                                                                                                                                                                                                      type ObjectMethod

                                                                                                                                                                                                                                                                                                                                                                      type ObjectMethod = astTypes.namedTypes.ObjectMethod;

                                                                                                                                                                                                                                                                                                                                                                        type ObjectPattern

                                                                                                                                                                                                                                                                                                                                                                        type ObjectPattern = astTypes.namedTypes.ObjectPattern;

                                                                                                                                                                                                                                                                                                                                                                          type ObjectProperty

                                                                                                                                                                                                                                                                                                                                                                          type ObjectProperty = astTypes.namedTypes.ObjectProperty;

                                                                                                                                                                                                                                                                                                                                                                            type ObjectTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                            type ObjectTypeAnnotation = astTypes.namedTypes.ObjectTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                              type ObjectTypeCallProperty

                                                                                                                                                                                                                                                                                                                                                                              type ObjectTypeCallProperty = astTypes.namedTypes.ObjectTypeCallProperty;

                                                                                                                                                                                                                                                                                                                                                                                type ObjectTypeIndexer

                                                                                                                                                                                                                                                                                                                                                                                type ObjectTypeIndexer = astTypes.namedTypes.ObjectTypeIndexer;

                                                                                                                                                                                                                                                                                                                                                                                  type ObjectTypeInternalSlot

                                                                                                                                                                                                                                                                                                                                                                                  type ObjectTypeInternalSlot = astTypes.namedTypes.ObjectTypeInternalSlot;

                                                                                                                                                                                                                                                                                                                                                                                    type ObjectTypeProperty

                                                                                                                                                                                                                                                                                                                                                                                    type ObjectTypeProperty = astTypes.namedTypes.ObjectTypeProperty;

                                                                                                                                                                                                                                                                                                                                                                                      type ObjectTypeSpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                      type ObjectTypeSpreadProperty = astTypes.namedTypes.ObjectTypeSpreadProperty;

                                                                                                                                                                                                                                                                                                                                                                                        type OpaqueType

                                                                                                                                                                                                                                                                                                                                                                                        type OpaqueType = astTypes.namedTypes.OpaqueType;

                                                                                                                                                                                                                                                                                                                                                                                          type OptionalCallExpression

                                                                                                                                                                                                                                                                                                                                                                                          type OptionalCallExpression = astTypes.namedTypes.OptionalCallExpression;

                                                                                                                                                                                                                                                                                                                                                                                            type OptionalMemberExpression

                                                                                                                                                                                                                                                                                                                                                                                            type OptionalMemberExpression = astTypes.namedTypes.OptionalMemberExpression;

                                                                                                                                                                                                                                                                                                                                                                                              type ParenthesizedExpression

                                                                                                                                                                                                                                                                                                                                                                                              type ParenthesizedExpression = astTypes.namedTypes.ParenthesizedExpression;

                                                                                                                                                                                                                                                                                                                                                                                                type Pattern

                                                                                                                                                                                                                                                                                                                                                                                                type Pattern = astTypes.namedTypes.Pattern;

                                                                                                                                                                                                                                                                                                                                                                                                  type Position

                                                                                                                                                                                                                                                                                                                                                                                                  type Position = astTypes.namedTypes.Position;

                                                                                                                                                                                                                                                                                                                                                                                                    type Printable

                                                                                                                                                                                                                                                                                                                                                                                                    type Printable = astTypes.namedTypes.Printable;

                                                                                                                                                                                                                                                                                                                                                                                                      type PrivateName

                                                                                                                                                                                                                                                                                                                                                                                                      type PrivateName = astTypes.namedTypes.PrivateName;

                                                                                                                                                                                                                                                                                                                                                                                                        type Program

                                                                                                                                                                                                                                                                                                                                                                                                        type Program = astTypes.namedTypes.Program;

                                                                                                                                                                                                                                                                                                                                                                                                          type Property

                                                                                                                                                                                                                                                                                                                                                                                                          type Property = astTypes.namedTypes.Property;

                                                                                                                                                                                                                                                                                                                                                                                                            type PropertyPattern

                                                                                                                                                                                                                                                                                                                                                                                                            type PropertyPattern = astTypes.namedTypes.PropertyPattern;

                                                                                                                                                                                                                                                                                                                                                                                                              type QualifiedTypeIdentifier

                                                                                                                                                                                                                                                                                                                                                                                                              type QualifiedTypeIdentifier = astTypes.namedTypes.QualifiedTypeIdentifier;

                                                                                                                                                                                                                                                                                                                                                                                                                type RegExpLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                type RegExpLiteral = astTypes.namedTypes.RegExpLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                  type RestElement

                                                                                                                                                                                                                                                                                                                                                                                                                  type RestElement = astTypes.namedTypes.RestElement;

                                                                                                                                                                                                                                                                                                                                                                                                                    type RestProperty

                                                                                                                                                                                                                                                                                                                                                                                                                    type RestProperty = astTypes.namedTypes.RestProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                      type ReturnStatement

                                                                                                                                                                                                                                                                                                                                                                                                                      type ReturnStatement = astTypes.namedTypes.ReturnStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                        type SequenceExpression

                                                                                                                                                                                                                                                                                                                                                                                                                        type SequenceExpression = astTypes.namedTypes.SequenceExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                          type SourceLocation

                                                                                                                                                                                                                                                                                                                                                                                                                          type SourceLocation = astTypes.namedTypes.SourceLocation;

                                                                                                                                                                                                                                                                                                                                                                                                                            type Specifier

                                                                                                                                                                                                                                                                                                                                                                                                                            type Specifier = astTypes.namedTypes.Specifier;

                                                                                                                                                                                                                                                                                                                                                                                                                              type SpreadElement

                                                                                                                                                                                                                                                                                                                                                                                                                              type SpreadElement = astTypes.namedTypes.SpreadElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                type SpreadElementPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                type SpreadElementPattern = astTypes.namedTypes.SpreadElementPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                  type SpreadProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                  type SpreadProperty = astTypes.namedTypes.SpreadProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SpreadPropertyPattern

                                                                                                                                                                                                                                                                                                                                                                                                                                    type SpreadPropertyPattern = astTypes.namedTypes.SpreadPropertyPattern;

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Statement

                                                                                                                                                                                                                                                                                                                                                                                                                                      type Statement = astTypes.namedTypes.Statement;

                                                                                                                                                                                                                                                                                                                                                                                                                                        type StringLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                        type StringLiteral = astTypes.namedTypes.StringLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                          type StringLiteralTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                          type StringLiteralTypeAnnotation = astTypes.namedTypes.StringLiteralTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                            type StringTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                            type StringTypeAnnotation = astTypes.namedTypes.StringTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                              type Super

                                                                                                                                                                                                                                                                                                                                                                                                                                              type Super = astTypes.namedTypes.Super;

                                                                                                                                                                                                                                                                                                                                                                                                                                                type SwitchCase

                                                                                                                                                                                                                                                                                                                                                                                                                                                type SwitchCase = astTypes.namedTypes.SwitchCase;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SwitchStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SwitchStatement = astTypes.namedTypes.SwitchStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SymbolTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SymbolTypeAnnotation = astTypes.namedTypes.SymbolTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TaggedTemplateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TaggedTemplateExpression = astTypes.namedTypes.TaggedTemplateExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TemplateElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TemplateElement = astTypes.namedTypes.TemplateElement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TemplateLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TemplateLiteral = astTypes.namedTypes.TemplateLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ThisExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                            type ThisExpression = astTypes.namedTypes.ThisExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThisTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                              type ThisTypeAnnotation = astTypes.namedTypes.ThisTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThrowStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                type ThrowStatement = astTypes.namedTypes.ThrowStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TryStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TryStatement = astTypes.namedTypes.TryStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSAnyKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSAnyKeyword = astTypes.namedTypes.TSAnyKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSArrayType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSArrayType = astTypes.namedTypes.TSArrayType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSAsExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSAsExpression = astTypes.namedTypes.TSAsExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSBigIntKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSBigIntKeyword = astTypes.namedTypes.TSBigIntKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSBooleanKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSBooleanKeyword = astTypes.namedTypes.TSBooleanKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSCallSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSCallSignatureDeclaration = astTypes.namedTypes.TSCallSignatureDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSConditionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSConditionalType = astTypes.namedTypes.TSConditionalType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSConstructorType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSConstructorType = astTypes.namedTypes.TSConstructorType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSConstructSignatureDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSConstructSignatureDeclaration =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    astTypes.namedTypes.TSConstructSignatureDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSDeclareFunction

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSDeclareFunction = astTypes.namedTypes.TSDeclareFunction;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSDeclareMethod

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSDeclareMethod = astTypes.namedTypes.TSDeclareMethod;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSEnumDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSEnumDeclaration = astTypes.namedTypes.TSEnumDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSEnumMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSEnumMember = astTypes.namedTypes.TSEnumMember;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSExportAssignment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSExportAssignment = astTypes.namedTypes.TSExportAssignment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSExpressionWithTypeArguments

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSExpressionWithTypeArguments =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                astTypes.namedTypes.TSExpressionWithTypeArguments;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSExternalModuleReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSExternalModuleReference = astTypes.namedTypes.TSExternalModuleReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSFunctionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSFunctionType = astTypes.namedTypes.TSFunctionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSHasOptionalTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSHasOptionalTypeAnnotation = astTypes.namedTypes.TSHasOptionalTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSHasOptionalTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSHasOptionalTypeParameterInstantiation =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        astTypes.namedTypes.TSHasOptionalTypeParameterInstantiation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSHasOptionalTypeParameters

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSHasOptionalTypeParameters = astTypes.namedTypes.TSHasOptionalTypeParameters;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSImportEqualsDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSImportEqualsDeclaration = astTypes.namedTypes.TSImportEqualsDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSImportType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSImportType = astTypes.namedTypes.TSImportType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSIndexedAccessType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSIndexedAccessType = astTypes.namedTypes.TSIndexedAccessType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSIndexSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSIndexSignature = astTypes.namedTypes.TSIndexSignature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSInferType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSInferType = astTypes.namedTypes.TSInferType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSInterfaceBody

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSInterfaceBody = astTypes.namedTypes.TSInterfaceBody;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSInterfaceDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSInterfaceDeclaration = astTypes.namedTypes.TSInterfaceDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSIntersectionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSIntersectionType = astTypes.namedTypes.TSIntersectionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSLiteralType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSLiteralType = astTypes.namedTypes.TSLiteralType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSMappedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSMappedType = astTypes.namedTypes.TSMappedType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSMethodSignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSMethodSignature = astTypes.namedTypes.TSMethodSignature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSModuleBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSModuleBlock = astTypes.namedTypes.TSModuleBlock;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSModuleDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSModuleDeclaration = astTypes.namedTypes.TSModuleDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSNamedTupleMember

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSNamedTupleMember = astTypes.namedTypes.TSNamedTupleMember;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSNamespaceExportDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSNamespaceExportDeclaration = astTypes.namedTypes.TSNamespaceExportDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSNeverKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSNeverKeyword = astTypes.namedTypes.TSNeverKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSNonNullExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSNonNullExpression = astTypes.namedTypes.TSNonNullExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSNullKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSNullKeyword = astTypes.namedTypes.TSNullKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSNumberKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSNumberKeyword = astTypes.namedTypes.TSNumberKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSObjectKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSObjectKeyword = astTypes.namedTypes.TSObjectKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSOptionalType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSOptionalType = astTypes.namedTypes.TSOptionalType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSParameterProperty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSParameterProperty = astTypes.namedTypes.TSParameterProperty;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSParenthesizedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSParenthesizedType = astTypes.namedTypes.TSParenthesizedType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSPropertySignature

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSPropertySignature = astTypes.namedTypes.TSPropertySignature;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSQualifiedName

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSQualifiedName = astTypes.namedTypes.TSQualifiedName;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSRestType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSRestType = astTypes.namedTypes.TSRestType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSStringKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSStringKeyword = astTypes.namedTypes.TSStringKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSSymbolKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSSymbolKeyword = astTypes.namedTypes.TSSymbolKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSThisType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSThisType = astTypes.namedTypes.TSThisType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSTupleType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSTupleType = astTypes.namedTypes.TSTupleType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSType = astTypes.namedTypes.TSType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSTypeAliasDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSTypeAliasDeclaration = astTypes.namedTypes.TSTypeAliasDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSTypeAnnotation = astTypes.namedTypes.TSTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSTypeAssertion

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSTypeAssertion = astTypes.namedTypes.TSTypeAssertion;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSTypeLiteral

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSTypeLiteral = astTypes.namedTypes.TSTypeLiteral;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSTypeOperator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSTypeOperator = astTypes.namedTypes.TSTypeOperator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSTypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSTypeParameter = astTypes.namedTypes.TSTypeParameter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSTypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSTypeParameterDeclaration = astTypes.namedTypes.TSTypeParameterDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSTypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TSTypeParameterInstantiation = astTypes.namedTypes.TSTypeParameterInstantiation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSTypePredicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TSTypePredicate = astTypes.namedTypes.TSTypePredicate;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSTypeQuery

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TSTypeQuery = astTypes.namedTypes.TSTypeQuery;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSTypeReference

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TSTypeReference = astTypes.namedTypes.TSTypeReference;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSUndefinedKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TSUndefinedKeyword = astTypes.namedTypes.TSUndefinedKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSUnionType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TSUnionType = astTypes.namedTypes.TSUnionType;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSUnknownKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TSUnknownKeyword = astTypes.namedTypes.TSUnknownKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSVoidKeyword

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TSVoidKeyword = astTypes.namedTypes.TSVoidKeyword;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TupleTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type TupleTypeAnnotation = astTypes.namedTypes.TupleTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TypeAlias

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TypeAlias = astTypes.namedTypes.TypeAlias;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type TypeAnnotation = astTypes.namedTypes.TypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeCastExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TypeCastExpression = astTypes.namedTypes.TypeCastExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TypeofTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TypeofTypeAnnotation = astTypes.namedTypes.TypeofTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypeParameter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TypeParameter = astTypes.namedTypes.TypeParameter;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TypeParameterDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TypeParameterDeclaration = astTypes.namedTypes.TypeParameterDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TypeParameterInstantiation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TypeParameterInstantiation = astTypes.namedTypes.TypeParameterInstantiation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UnaryExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type UnaryExpression = astTypes.namedTypes.UnaryExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnionTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type UnionTypeAnnotation = astTypes.namedTypes.UnionTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateExpression = astTypes.namedTypes.UpdateExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VariableDeclaration

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type VariableDeclaration = astTypes.namedTypes.VariableDeclaration;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VariableDeclarator

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type VariableDeclarator = astTypes.namedTypes.VariableDeclarator;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Variance

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Variance = astTypes.namedTypes.Variance;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VoidTypeAnnotation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type VoidTypeAnnotation = astTypes.namedTypes.VoidTypeAnnotation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WhileStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type WhileStatement = astTypes.namedTypes.WhileStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WithStatement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type WithStatement = astTypes.namedTypes.WithStatement;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type YieldExpression

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type YieldExpression = astTypes.namedTypes.YieldExpression;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Package Files (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Peer Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            No peer dependencies.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Badge

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/@types/jscodeshift.

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