import * as t from '@babel/types'; import { Node, RemovePropertiesOptions } from '@babel/types'; type BindingKind = "var" | "let" | "const" | "module" | "hoisted" | "param" | "local" | "unknown"; /** * This class is responsible for a binding inside of a scope. * * It tracks the following: * * * Node path. * * Amount of times referenced by other nodes. * * Paths to nodes that reassign or modify this binding. * * The kind of binding. (Is it a parameter, declaration etc) */ declare class Binding { identifier: t.Identifier; scope: Scope; path: NodePath_Final; kind: BindingKind; constructor({ identifier, scope, path, kind, }: { identifier: t.Identifier; scope: Scope; path: NodePath_Final; kind: BindingKind; }); constantViolations: NodePath_Final[]; constant: boolean; referencePaths: NodePath_Final[]; referenced: boolean; references: number; hasDeoptedValue: boolean; hasValue: boolean; value: any; deoptValue(): void; setValue(value: any): void; clearValue(): void; /** * Register a constant violation with the provided `path`. */ reassign(path: NodePath_Final): void; /** * Increment the amount of references to this binding. */ reference(path: NodePath_Final): void; /** * Decrement the amount of references to this binding. */ dereference(): void; } type _Binding = Binding; declare class Scope { uid: number | undefined; path: NodePath_Final; block: t.Pattern | t.Scopable; inited: boolean; labels: Map>; bindings: Record; /** Only defined in the program scope */ referencesSet?: Set; globals: Record; /** Only defined in the program scope */ uidsSet?: Set; data: Record; crawling: boolean; /** * This searches the current "scope" and collects all references/bindings * within. */ constructor(path: NodePath_Final); /** * Globals. */ static globals: string[]; /** * Variables available in current context. */ static contextVariables: string[]; get parent(): Scope | undefined; get references(): void; get uids(): void; /** * Generate a unique identifier and add it to the current scope. */ generateDeclaredUidIdentifier(name?: string): t.Identifier; /** * Generate a unique identifier. */ generateUidIdentifier(name?: string): t.Identifier; /** * Generate a unique `_id1` binding. */ generateUid(name?: string): string; generateUidBasedOnNode(node: t.Node | undefined | null, defaultName?: string): string; /** * Generate a unique identifier based on a node. */ generateUidIdentifierBasedOnNode(node: t.Node | undefined | null, defaultName?: string): t.Identifier; /** * Determine whether evaluating the specific input `node` is a consequenceless reference. ie. * evaluating it won't result in potentially arbitrary code from being ran. The following are * allowed and determined not to cause side effects: * * - `this` expressions * - `super` expressions * - Bound identifiers */ isStatic(node: t.Node | null): boolean; /** * Possibly generate a memoised identifier if it is not static and has consequences. */ maybeGenerateMemoised(node: t.Node, dontPush?: boolean): t.Identifier | null; checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: any): void; rename(oldName: string, newName?: string): void; dump(): void; hasLabel(name: string): boolean; getLabel(name: string): NodePath> | undefined; registerLabel(path: NodePath_Final): void; registerDeclaration(path: NodePath_Final): void; registerConstantViolation(path: NodePath_Final): void; registerBinding(kind: Binding["kind"], path: NodePath_Final, bindingPath?: NodePath_Final): void; addGlobal(node: t.Identifier | t.JSXIdentifier): void; hasUid(name: string): boolean; hasGlobal(name: string): boolean; hasReference(name: string): boolean; isPure(node: t.Node | null | undefined, constantsOnly?: boolean): boolean; /** * Set some arbitrary data on the current scope. */ setData(key: string | symbol, val: any): any; /** * Recursively walk up scope tree looking for the data `key`. */ getData(key: string | symbol): any; /** * Recursively walk up scope tree looking for the data `key` and if it exists, * remove it. */ removeData(key: string): void; init(): void; crawl(): void; push(opts: { id: t.ArrayPattern | t.Identifier | t.ObjectPattern; init?: t.Expression; unique?: boolean; _blockHoist?: number | undefined; kind?: "var" | "let" | "const"; }): void; /** * Walk up to the top of the scope tree and get the `Program`. */ getProgramParent(): Scope & { referencesSet: Set; uidsSet: Set; }; /** * Walk up the scope tree until we hit either a Function or return null. */ getFunctionParent(): Scope | null; /** * Walk up the scope tree until we hit either a BlockStatement/Loop/Program/Function/Switch or reach the * very top and hit Program. */ getBlockParent(): Scope; /** * Walk up from a pattern scope (function param initializer) until we hit a non-pattern scope, * then returns its block parent * @returns An ancestry scope whose path is a block parent */ getPatternParent(): Scope; /** * Walks the scope tree and gathers **all** bindings. */ getAllBindings(): Record; bindingIdentifierEquals(name: string, node: t.Node): boolean; getBinding(name: string): Binding | undefined; getOwnBinding(name: string): Binding | undefined; getBindingIdentifier(name: string): t.Identifier | undefined; getOwnBindingIdentifier(name: string): t.Identifier | undefined; hasOwnBinding(name: string): boolean; hasBinding(name: string, opts?: boolean | { noGlobals?: boolean; noUids?: boolean; upToScope?: Scope; }): boolean; parentHasBinding(name: string, opts?: { noGlobals?: boolean; noUids?: boolean; }): boolean | undefined; /** * Move a binding of `name` to another `scope`. */ moveBindingTo(name: string, scope: Scope): void; removeOwnBinding(name: string): void; removeBinding(name: string): void; /** * Hoist all the `var` variable to the beginning of the function/program * scope where their binding will be actually defined. For exmaple, * { var x = 2 } * will be transformed to * var x; { x = 2 } * * @param emit A custom function to emit `var` declarations, for example to * emit them in a different scope. */ hoistVariables(emit?: (id: t.Identifier, hasInit: boolean) => void): void; } declare namespace Scope { type Binding = _Binding; } //# sourceMappingURL=index.d.ts.map interface HubInterface { getCode(): string | void; getScope(): Scope | void; addHelper(name: string): any; buildError(node: Node, msg: string, Error: new (msg: string) => Error): Error; } declare class Hub implements HubInterface { getCode(): void; getScope(): void; addHelper(): void; buildError(node: Node, msg: string, Error?: new (msg: string) => Error): Error; } interface VirtualTypeAliases { BindingIdentifier: t.Identifier; BlockScoped: t.FunctionDeclaration | t.ClassDeclaration | t.VariableDeclaration; ExistentialTypeParam: t.ExistsTypeAnnotation; Expression: t.Expression; Flow: t.Flow | t.ImportDeclaration | t.ExportDeclaration | t.ImportSpecifier; ForAwaitStatement: t.ForOfStatement; Generated: t.Node; NumericLiteralTypeAnnotation: t.NumberLiteralTypeAnnotation; Pure: t.Node; Referenced: t.Node; ReferencedIdentifier: t.Identifier | t.JSXIdentifier; ReferencedMemberExpression: t.MemberExpression; RestProperty: t.RestElement; Scope: t.Scopable | t.Pattern; SpreadProperty: t.RestElement; Statement: t.Statement; User: t.Node; Var: t.VariableDeclaration; } /* * This file is auto-generated! Do not modify it directly. * To re-generate run 'make build' */ interface ExplVisitorBase { AnyTypeAnnotation?: ExplVisitNode; ArgumentPlaceholder?: ExplVisitNode; ArrayExpression?: ExplVisitNode; ArrayPattern?: ExplVisitNode; ArrayTypeAnnotation?: ExplVisitNode; ArrowFunctionExpression?: ExplVisitNode; AssignmentExpression?: ExplVisitNode; AssignmentPattern?: ExplVisitNode; AwaitExpression?: ExplVisitNode; BigIntLiteral?: ExplVisitNode; BigIntLiteralTypeAnnotation?: ExplVisitNode; BinaryExpression?: ExplVisitNode; BindExpression?: ExplVisitNode; BlockStatement?: ExplVisitNode; BooleanLiteral?: ExplVisitNode; BooleanLiteralTypeAnnotation?: ExplVisitNode< S, t.BooleanLiteralTypeAnnotation >; BooleanTypeAnnotation?: ExplVisitNode; BreakStatement?: ExplVisitNode; CallExpression?: ExplVisitNode; CatchClause?: ExplVisitNode; ClassAccessorProperty?: ExplVisitNode; ClassBody?: ExplVisitNode; ClassDeclaration?: ExplVisitNode; ClassExpression?: ExplVisitNode; ClassImplements?: ExplVisitNode; ClassMethod?: ExplVisitNode; ClassPrivateMethod?: ExplVisitNode; ClassPrivateProperty?: ExplVisitNode; ClassProperty?: ExplVisitNode; ConditionalExpression?: ExplVisitNode; ContinueStatement?: ExplVisitNode; DebuggerStatement?: ExplVisitNode; DeclareClass?: ExplVisitNode; DeclareExportAllDeclaration?: ExplVisitNode; DeclareExportDeclaration?: ExplVisitNode; DeclareFunction?: ExplVisitNode; DeclareInterface?: ExplVisitNode; DeclareModule?: ExplVisitNode; DeclareModuleExports?: ExplVisitNode; DeclareOpaqueType?: ExplVisitNode; DeclareTypeAlias?: ExplVisitNode; DeclareVariable?: ExplVisitNode; DeclaredPredicate?: ExplVisitNode; Decorator?: ExplVisitNode; Directive?: ExplVisitNode; DirectiveLiteral?: ExplVisitNode; DoExpression?: ExplVisitNode; DoWhileStatement?: ExplVisitNode; EmptyStatement?: ExplVisitNode; EmptyTypeAnnotation?: ExplVisitNode; EnumBooleanBody?: ExplVisitNode; EnumBooleanMember?: ExplVisitNode; EnumDeclaration?: ExplVisitNode; EnumDefaultedMember?: ExplVisitNode; EnumNumberBody?: ExplVisitNode; EnumNumberMember?: ExplVisitNode; EnumStringBody?: ExplVisitNode; EnumStringMember?: ExplVisitNode; EnumSymbolBody?: ExplVisitNode; ExistsTypeAnnotation?: ExplVisitNode; ExportAllDeclaration?: ExplVisitNode; ExportDefaultDeclaration?: ExplVisitNode; ExportDefaultSpecifier?: ExplVisitNode; ExportNamedDeclaration?: ExplVisitNode; ExportNamespaceSpecifier?: ExplVisitNode; ExportSpecifier?: ExplVisitNode; ExpressionStatement?: ExplVisitNode; File?: ExplVisitNode; ForInStatement?: ExplVisitNode; ForOfStatement?: ExplVisitNode; ForStatement?: ExplVisitNode; FunctionDeclaration?: ExplVisitNode; FunctionExpression?: ExplVisitNode; FunctionTypeAnnotation?: ExplVisitNode; FunctionTypeParam?: ExplVisitNode; GenericTypeAnnotation?: ExplVisitNode; Identifier?: ExplVisitNode; IfStatement?: ExplVisitNode; Import?: ExplVisitNode; ImportAttribute?: ExplVisitNode; ImportDeclaration?: ExplVisitNode; ImportDefaultSpecifier?: ExplVisitNode; ImportExpression?: ExplVisitNode; ImportNamespaceSpecifier?: ExplVisitNode; ImportSpecifier?: ExplVisitNode; IndexedAccessType?: ExplVisitNode; InferredPredicate?: ExplVisitNode; InterfaceDeclaration?: ExplVisitNode; InterfaceExtends?: ExplVisitNode; InterfaceTypeAnnotation?: ExplVisitNode; InterpreterDirective?: ExplVisitNode; IntersectionTypeAnnotation?: ExplVisitNode; JSXAttribute?: ExplVisitNode; JSXClosingElement?: ExplVisitNode; JSXClosingFragment?: ExplVisitNode; JSXElement?: ExplVisitNode; JSXEmptyExpression?: ExplVisitNode; JSXExpressionContainer?: ExplVisitNode; JSXFragment?: ExplVisitNode; JSXIdentifier?: ExplVisitNode; JSXMemberExpression?: ExplVisitNode; JSXNamespacedName?: ExplVisitNode; JSXOpeningElement?: ExplVisitNode; JSXOpeningFragment?: ExplVisitNode; JSXSpreadAttribute?: ExplVisitNode; JSXSpreadChild?: ExplVisitNode; JSXText?: ExplVisitNode; LabeledStatement?: ExplVisitNode; LogicalExpression?: ExplVisitNode; MemberExpression?: ExplVisitNode; MetaProperty?: ExplVisitNode; MixedTypeAnnotation?: ExplVisitNode; ModuleExpression?: ExplVisitNode; NewExpression?: ExplVisitNode; NullLiteral?: ExplVisitNode; NullLiteralTypeAnnotation?: ExplVisitNode; NullableTypeAnnotation?: ExplVisitNode; NumberLiteral?: ExplVisitNode; NumberLiteralTypeAnnotation?: ExplVisitNode; NumberTypeAnnotation?: ExplVisitNode; NumericLiteral?: ExplVisitNode; ObjectExpression?: ExplVisitNode; ObjectMethod?: ExplVisitNode; ObjectPattern?: ExplVisitNode; ObjectProperty?: ExplVisitNode; ObjectTypeAnnotation?: ExplVisitNode; ObjectTypeCallProperty?: ExplVisitNode; ObjectTypeIndexer?: ExplVisitNode; ObjectTypeInternalSlot?: ExplVisitNode; ObjectTypeProperty?: ExplVisitNode; ObjectTypeSpreadProperty?: ExplVisitNode; OpaqueType?: ExplVisitNode; OptionalCallExpression?: ExplVisitNode; OptionalIndexedAccessType?: ExplVisitNode; OptionalMemberExpression?: ExplVisitNode; ParenthesizedExpression?: ExplVisitNode; Placeholder?: ExplVisitNode; PrivateName?: ExplVisitNode; Program?: ExplVisitNode; QualifiedTypeIdentifier?: ExplVisitNode; RegExpLiteral?: ExplVisitNode; RegexLiteral?: ExplVisitNode; RestElement?: ExplVisitNode; RestProperty?: ExplVisitNode; ReturnStatement?: ExplVisitNode; SequenceExpression?: ExplVisitNode; SpreadElement?: ExplVisitNode; SpreadProperty?: ExplVisitNode; StaticBlock?: ExplVisitNode; StringLiteral?: ExplVisitNode; StringLiteralTypeAnnotation?: ExplVisitNode; StringTypeAnnotation?: ExplVisitNode; Super?: ExplVisitNode; SwitchCase?: ExplVisitNode; SwitchStatement?: ExplVisitNode; SymbolTypeAnnotation?: ExplVisitNode; TSAnyKeyword?: ExplVisitNode; TSArrayType?: ExplVisitNode; TSAsExpression?: ExplVisitNode; TSBigIntKeyword?: ExplVisitNode; TSBooleanKeyword?: ExplVisitNode; TSCallSignatureDeclaration?: ExplVisitNode; TSClassImplements?: ExplVisitNode; TSConditionalType?: ExplVisitNode; TSConstructSignatureDeclaration?: ExplVisitNode< S, t.TSConstructSignatureDeclaration >; TSConstructorType?: ExplVisitNode; TSDeclareFunction?: ExplVisitNode; TSDeclareMethod?: ExplVisitNode; TSEnumBody?: ExplVisitNode; TSEnumDeclaration?: ExplVisitNode; TSEnumMember?: ExplVisitNode; TSExportAssignment?: ExplVisitNode; TSExternalModuleReference?: ExplVisitNode; TSFunctionType?: ExplVisitNode; TSImportEqualsDeclaration?: ExplVisitNode; TSImportType?: ExplVisitNode; TSIndexSignature?: ExplVisitNode; TSIndexedAccessType?: ExplVisitNode; TSInferType?: ExplVisitNode; TSInstantiationExpression?: ExplVisitNode; TSInterfaceBody?: ExplVisitNode; TSInterfaceDeclaration?: ExplVisitNode; TSInterfaceHeritage?: ExplVisitNode; TSIntersectionType?: ExplVisitNode; TSIntrinsicKeyword?: ExplVisitNode; TSLiteralType?: ExplVisitNode; TSMappedType?: ExplVisitNode; TSMethodSignature?: ExplVisitNode; TSModuleBlock?: ExplVisitNode; TSModuleDeclaration?: ExplVisitNode; TSNamedTupleMember?: ExplVisitNode; TSNamespaceExportDeclaration?: ExplVisitNode< S, t.TSNamespaceExportDeclaration >; TSNeverKeyword?: ExplVisitNode; TSNonNullExpression?: ExplVisitNode; TSNullKeyword?: ExplVisitNode; TSNumberKeyword?: ExplVisitNode; TSObjectKeyword?: ExplVisitNode; TSOptionalType?: ExplVisitNode; TSParameterProperty?: ExplVisitNode; TSParenthesizedType?: ExplVisitNode; TSPropertySignature?: ExplVisitNode; TSQualifiedName?: ExplVisitNode; TSRestType?: ExplVisitNode; TSSatisfiesExpression?: ExplVisitNode; TSStringKeyword?: ExplVisitNode; TSSymbolKeyword?: ExplVisitNode; TSTemplateLiteralType?: ExplVisitNode; TSThisType?: ExplVisitNode; TSTupleType?: ExplVisitNode; TSTypeAliasDeclaration?: ExplVisitNode; TSTypeAnnotation?: ExplVisitNode; TSTypeAssertion?: ExplVisitNode; TSTypeLiteral?: ExplVisitNode; TSTypeOperator?: ExplVisitNode; TSTypeParameter?: ExplVisitNode; TSTypeParameterDeclaration?: ExplVisitNode; TSTypeParameterInstantiation?: ExplVisitNode< S, t.TSTypeParameterInstantiation >; TSTypePredicate?: ExplVisitNode; TSTypeQuery?: ExplVisitNode; TSTypeReference?: ExplVisitNode; TSUndefinedKeyword?: ExplVisitNode; TSUnionType?: ExplVisitNode; TSUnknownKeyword?: ExplVisitNode; TSVoidKeyword?: ExplVisitNode; TaggedTemplateExpression?: ExplVisitNode; TemplateElement?: ExplVisitNode; TemplateLiteral?: ExplVisitNode; ThisExpression?: ExplVisitNode; ThisTypeAnnotation?: ExplVisitNode; ThrowStatement?: ExplVisitNode; TopicReference?: ExplVisitNode; TryStatement?: ExplVisitNode; TupleTypeAnnotation?: ExplVisitNode; TypeAlias?: ExplVisitNode; TypeAnnotation?: ExplVisitNode; TypeCastExpression?: ExplVisitNode; TypeParameter?: ExplVisitNode; TypeParameterDeclaration?: ExplVisitNode; TypeParameterInstantiation?: ExplVisitNode; TypeofTypeAnnotation?: ExplVisitNode; UnaryExpression?: ExplVisitNode; UnionTypeAnnotation?: ExplVisitNode; UpdateExpression?: ExplVisitNode; V8IntrinsicIdentifier?: ExplVisitNode; VariableDeclaration?: ExplVisitNode; VariableDeclarator?: ExplVisitNode; Variance?: ExplVisitNode; VoidPattern?: ExplVisitNode; VoidTypeAnnotation?: ExplVisitNode; WhileStatement?: ExplVisitNode; WithStatement?: ExplVisitNode; YieldExpression?: ExplVisitNode; } interface VisitorBaseNodes { AnyTypeAnnotation?: VisitNode; ArgumentPlaceholder?: VisitNode; ArrayExpression?: VisitNode; ArrayPattern?: VisitNode; ArrayTypeAnnotation?: VisitNode; ArrowFunctionExpression?: VisitNode; AssignmentExpression?: VisitNode; AssignmentPattern?: VisitNode; AwaitExpression?: VisitNode; BigIntLiteral?: VisitNode; BigIntLiteralTypeAnnotation?: VisitNode; BinaryExpression?: VisitNode; BindExpression?: VisitNode; BlockStatement?: VisitNode; BooleanLiteral?: VisitNode; BooleanLiteralTypeAnnotation?: VisitNode; BooleanTypeAnnotation?: VisitNode; BreakStatement?: VisitNode; CallExpression?: VisitNode; CatchClause?: VisitNode; ClassAccessorProperty?: VisitNode; ClassBody?: VisitNode; ClassDeclaration?: VisitNode; ClassExpression?: VisitNode; ClassImplements?: VisitNode; ClassMethod?: VisitNode; ClassPrivateMethod?: VisitNode; ClassPrivateProperty?: VisitNode; ClassProperty?: VisitNode; ConditionalExpression?: VisitNode; ContinueStatement?: VisitNode; DebuggerStatement?: VisitNode; DeclareClass?: VisitNode; DeclareExportAllDeclaration?: VisitNode; DeclareExportDeclaration?: VisitNode; DeclareFunction?: VisitNode; DeclareInterface?: VisitNode; DeclareModule?: VisitNode; DeclareModuleExports?: VisitNode; DeclareOpaqueType?: VisitNode; DeclareTypeAlias?: VisitNode; DeclareVariable?: VisitNode; DeclaredPredicate?: VisitNode; Decorator?: VisitNode; Directive?: VisitNode; DirectiveLiteral?: VisitNode; DoExpression?: VisitNode; DoWhileStatement?: VisitNode; EmptyStatement?: VisitNode; EmptyTypeAnnotation?: VisitNode; EnumBooleanBody?: VisitNode; EnumBooleanMember?: VisitNode; EnumDeclaration?: VisitNode; EnumDefaultedMember?: VisitNode; EnumNumberBody?: VisitNode; EnumNumberMember?: VisitNode; EnumStringBody?: VisitNode; EnumStringMember?: VisitNode; EnumSymbolBody?: VisitNode; ExistsTypeAnnotation?: VisitNode; ExportAllDeclaration?: VisitNode; ExportDefaultDeclaration?: VisitNode; ExportDefaultSpecifier?: VisitNode; ExportNamedDeclaration?: VisitNode; ExportNamespaceSpecifier?: VisitNode; ExportSpecifier?: VisitNode; ExpressionStatement?: VisitNode; File?: VisitNode; ForInStatement?: VisitNode; ForOfStatement?: VisitNode; ForStatement?: VisitNode; FunctionDeclaration?: VisitNode; FunctionExpression?: VisitNode; FunctionTypeAnnotation?: VisitNode; FunctionTypeParam?: VisitNode; GenericTypeAnnotation?: VisitNode; Identifier?: VisitNode; IfStatement?: VisitNode; Import?: VisitNode; ImportAttribute?: VisitNode; ImportDeclaration?: VisitNode; ImportDefaultSpecifier?: VisitNode; ImportExpression?: VisitNode; ImportNamespaceSpecifier?: VisitNode; ImportSpecifier?: VisitNode; IndexedAccessType?: VisitNode; InferredPredicate?: VisitNode; InterfaceDeclaration?: VisitNode; InterfaceExtends?: VisitNode; InterfaceTypeAnnotation?: VisitNode; InterpreterDirective?: VisitNode; IntersectionTypeAnnotation?: VisitNode; JSXAttribute?: VisitNode; JSXClosingElement?: VisitNode; JSXClosingFragment?: VisitNode; JSXElement?: VisitNode; JSXEmptyExpression?: VisitNode; JSXExpressionContainer?: VisitNode; JSXFragment?: VisitNode; JSXIdentifier?: VisitNode; JSXMemberExpression?: VisitNode; JSXNamespacedName?: VisitNode; JSXOpeningElement?: VisitNode; JSXOpeningFragment?: VisitNode; JSXSpreadAttribute?: VisitNode; JSXSpreadChild?: VisitNode; JSXText?: VisitNode; LabeledStatement?: VisitNode; LogicalExpression?: VisitNode; MemberExpression?: VisitNode; MetaProperty?: VisitNode; MixedTypeAnnotation?: VisitNode; ModuleExpression?: VisitNode; NewExpression?: VisitNode; NullLiteral?: VisitNode; NullLiteralTypeAnnotation?: VisitNode; NullableTypeAnnotation?: VisitNode; NumberLiteral?: VisitNode; NumberLiteralTypeAnnotation?: VisitNode; NumberTypeAnnotation?: VisitNode; NumericLiteral?: VisitNode; ObjectExpression?: VisitNode; ObjectMethod?: VisitNode; ObjectPattern?: VisitNode; ObjectProperty?: VisitNode; ObjectTypeAnnotation?: VisitNode; ObjectTypeCallProperty?: VisitNode; ObjectTypeIndexer?: VisitNode; ObjectTypeInternalSlot?: VisitNode; ObjectTypeProperty?: VisitNode; ObjectTypeSpreadProperty?: VisitNode; OpaqueType?: VisitNode; OptionalCallExpression?: VisitNode; OptionalIndexedAccessType?: VisitNode; OptionalMemberExpression?: VisitNode; ParenthesizedExpression?: VisitNode; Placeholder?: VisitNode; PrivateName?: VisitNode; Program?: VisitNode; QualifiedTypeIdentifier?: VisitNode; RegExpLiteral?: VisitNode; RegexLiteral?: VisitNode; RestElement?: VisitNode; RestProperty?: VisitNode; ReturnStatement?: VisitNode; SequenceExpression?: VisitNode; SpreadElement?: VisitNode; SpreadProperty?: VisitNode; StaticBlock?: VisitNode; StringLiteral?: VisitNode; StringLiteralTypeAnnotation?: VisitNode; StringTypeAnnotation?: VisitNode; Super?: VisitNode; SwitchCase?: VisitNode; SwitchStatement?: VisitNode; SymbolTypeAnnotation?: VisitNode; TSAnyKeyword?: VisitNode; TSArrayType?: VisitNode; TSAsExpression?: VisitNode; TSBigIntKeyword?: VisitNode; TSBooleanKeyword?: VisitNode; TSCallSignatureDeclaration?: VisitNode; TSClassImplements?: VisitNode; TSConditionalType?: VisitNode; TSConstructSignatureDeclaration?: VisitNode< S, t.TSConstructSignatureDeclaration >; TSConstructorType?: VisitNode; TSDeclareFunction?: VisitNode; TSDeclareMethod?: VisitNode; TSEnumBody?: VisitNode; TSEnumDeclaration?: VisitNode; TSEnumMember?: VisitNode; TSExportAssignment?: VisitNode; TSExternalModuleReference?: VisitNode; TSFunctionType?: VisitNode; TSImportEqualsDeclaration?: VisitNode; TSImportType?: VisitNode; TSIndexSignature?: VisitNode; TSIndexedAccessType?: VisitNode; TSInferType?: VisitNode; TSInstantiationExpression?: VisitNode; TSInterfaceBody?: VisitNode; TSInterfaceDeclaration?: VisitNode; TSInterfaceHeritage?: VisitNode; TSIntersectionType?: VisitNode; TSIntrinsicKeyword?: VisitNode; TSLiteralType?: VisitNode; TSMappedType?: VisitNode; TSMethodSignature?: VisitNode; TSModuleBlock?: VisitNode; TSModuleDeclaration?: VisitNode; TSNamedTupleMember?: VisitNode; TSNamespaceExportDeclaration?: VisitNode; TSNeverKeyword?: VisitNode; TSNonNullExpression?: VisitNode; TSNullKeyword?: VisitNode; TSNumberKeyword?: VisitNode; TSObjectKeyword?: VisitNode; TSOptionalType?: VisitNode; TSParameterProperty?: VisitNode; TSParenthesizedType?: VisitNode; TSPropertySignature?: VisitNode; TSQualifiedName?: VisitNode; TSRestType?: VisitNode; TSSatisfiesExpression?: VisitNode; TSStringKeyword?: VisitNode; TSSymbolKeyword?: VisitNode; TSTemplateLiteralType?: VisitNode; TSThisType?: VisitNode; TSTupleType?: VisitNode; TSTypeAliasDeclaration?: VisitNode; TSTypeAnnotation?: VisitNode; TSTypeAssertion?: VisitNode; TSTypeLiteral?: VisitNode; TSTypeOperator?: VisitNode; TSTypeParameter?: VisitNode; TSTypeParameterDeclaration?: VisitNode; TSTypeParameterInstantiation?: VisitNode; TSTypePredicate?: VisitNode; TSTypeQuery?: VisitNode; TSTypeReference?: VisitNode; TSUndefinedKeyword?: VisitNode; TSUnionType?: VisitNode; TSUnknownKeyword?: VisitNode; TSVoidKeyword?: VisitNode; TaggedTemplateExpression?: VisitNode; TemplateElement?: VisitNode; TemplateLiteral?: VisitNode; ThisExpression?: VisitNode; ThisTypeAnnotation?: VisitNode; ThrowStatement?: VisitNode; TopicReference?: VisitNode; TryStatement?: VisitNode; TupleTypeAnnotation?: VisitNode; TypeAlias?: VisitNode; TypeAnnotation?: VisitNode; TypeCastExpression?: VisitNode; TypeParameter?: VisitNode; TypeParameterDeclaration?: VisitNode; TypeParameterInstantiation?: VisitNode; TypeofTypeAnnotation?: VisitNode; UnaryExpression?: VisitNode; UnionTypeAnnotation?: VisitNode; UpdateExpression?: VisitNode; V8IntrinsicIdentifier?: VisitNode; VariableDeclaration?: VisitNode; VariableDeclarator?: VisitNode; Variance?: VisitNode; VoidPattern?: VisitNode; VoidTypeAnnotation?: VisitNode; WhileStatement?: VisitNode; WithStatement?: VisitNode; YieldExpression?: VisitNode; } interface VisitorBaseAliases { Accessor?: VisitNode; Binary?: VisitNode; Block?: VisitNode; BlockParent?: VisitNode; Class?: VisitNode; CompletionStatement?: VisitNode; Conditional?: VisitNode; Declaration?: VisitNode; EnumBody?: VisitNode; EnumMember?: VisitNode; ExportDeclaration?: VisitNode; Expression?: VisitNode; ExpressionWrapper?: VisitNode; Flow?: VisitNode; FlowBaseAnnotation?: VisitNode; FlowDeclaration?: VisitNode; FlowPredicate?: VisitNode; FlowType?: VisitNode; For?: VisitNode; ForXStatement?: VisitNode; Function?: VisitNode; FunctionParameter?: VisitNode; FunctionParent?: VisitNode; Immutable?: VisitNode; ImportOrExportDeclaration?: VisitNode; JSX?: VisitNode; LVal?: VisitNode; Literal?: VisitNode; Loop?: VisitNode; Method?: VisitNode; Miscellaneous?: VisitNode; ModuleDeclaration?: VisitNode; ModuleSpecifier?: VisitNode; ObjectMember?: VisitNode; Pattern?: VisitNode; PatternLike?: VisitNode; Private?: VisitNode; Property?: VisitNode; Pureish?: VisitNode; Scopable?: VisitNode; Standardized?: VisitNode; Statement?: VisitNode; TSBaseType?: VisitNode; TSEntityName?: VisitNode; TSType?: VisitNode; TSTypeElement?: VisitNode; Terminatorless?: VisitNode; TypeScript?: VisitNode; UnaryLike?: VisitNode; UserWhitespacable?: VisitNode; While?: VisitNode; } type VisitPhase = "enter" | "exit"; interface VisitNodeObject { enter?: VisitNodeFunction; exit?: VisitNodeFunction; } interface ExplVisitNode { enter?: VisitNodeFunction[]; exit?: VisitNodeFunction[]; } interface ExplodedVisitor extends ExplVisitorBase, ExplVisitNode { _exploded: true; _verified: true; } interface VisitorVirtualAliases { BindingIdentifier?: VisitNode; BlockScoped?: VisitNode; ExistentialTypeParam?: VisitNode; Expression?: VisitNode; ForAwaitStatement?: VisitNode; Generated?: VisitNode; NumericLiteralTypeAnnotation?: VisitNode; Pure?: VisitNode; Referenced?: VisitNode; ReferencedIdentifier?: VisitNode; ReferencedMemberExpression?: VisitNode; Scope?: VisitNode; Statement?: VisitNode; User?: VisitNode; Var?: VisitNode; } interface VisitorBase extends VisitNodeObject, VisitorBaseNodes, VisitorBaseAliases, VisitorVirtualAliases, Record<`${string}|${string}`, VisitNode> { } type Visitor = VisitorBase | ExplodedVisitor; type VisitNode = VisitNodeFunction | VisitNodeObject; type VisitNodeFunction = (this: S, path: NodePath_Final

, state: S) => void; type Split$1 = S extends `${infer L}|${infer R}` ? L | Split$1 : S; type ToNode> = N extends keyof t.Aliases ? t.Aliases[N] : N extends keyof VirtualTypeAliases ? VirtualTypeAliases[N] : Extract; type OptionKeys = keyof TraverseOptions; type VisitorProp = K extends OptionKeys ? TraverseOptions[K] : VisitNode>; type TraverseOptions = { scope?: Scope; noScope?: boolean; denylist?: string[]; shouldSkip?: (node: NodePath_Final) => boolean; }; declare class TraversalContext { constructor(opts: TraverseOptions & ExplodedVisitor, state: S); state: S; opts: TraverseOptions & ExplodedVisitor; queue: NodePath_Final[] | null; priorityQueue: NodePath_Final[] | null; maybeQueue(path: NodePath_Final, notPriority?: boolean): void; } /** * Starting at the parent path of the current `NodePath` and going up the * tree, return the first `NodePath` that causes the provided `callback` * to return a truthy value, or `null` if the `callback` never returns a * truthy value. */ declare function findParent(this: NodePath_Final, callback: (path: NodePath_Final) => boolean): NodePath_Final | null; /** * Starting at current `NodePath` and going up the tree, return the first * `NodePath` that causes the provided `callback` to return a truthy value, * or `null` if the `callback` never returns a truthy value. */ declare function find(this: NodePath_Final, callback: (path: NodePath_Final) => boolean): NodePath_Final | null; /** * Get the parent function of the current path. */ declare function getFunctionParent(this: NodePath_Final): NodePath_Final | null; /** * Walk up the tree until we hit a parent node path in a list. */ declare function getStatementParent(this: NodePath_Final): NodePath_Final; /** * Get the deepest common ancestor and then from it, get the earliest relationship path * to that ancestor. * * Earliest is defined as being "before" all the other nodes in terms of list container * position and visiting key. */ declare function getEarliestCommonAncestorFrom(this: NodePath_Final, paths: NodePath_Final[]): NodePath_Final; /** * Get the earliest path in the tree where the provided `paths` intersect. * * TODO: Possible optimisation target. */ declare function getDeepestCommonAncestorFrom(this: NodePath_Final, paths: NodePath_Final[], filter?: (deepest: NodePath_Final, i: number, ancestries: NodePath_Final[][]) => NodePath_Final): NodePath_Final; /** * Build an array of node paths containing the entire ancestry of the current node path. * * NOTE: The current node path is included in this. */ declare function getAncestry(this: NodePath_Final): NodePath_Final[]; /** * A helper to find if `this` path is an ancestor of @param maybeDescendant */ declare function isAncestor(this: NodePath_Final, maybeDescendant: NodePath_Final): boolean; /** * A helper to find if `this` path is a descendant of @param maybeAncestor */ declare function isDescendant(this: NodePath_Final, maybeAncestor: NodePath_Final): boolean; declare function inType(this: NodePath_Final, ...candidateTypes: string[]): boolean; /** * Infer the type of the current `NodePath`. */ declare function getTypeAnnotation(this: NodePath_Final): t.FlowType | t.TSType; declare function isBaseType(this: NodePath_Final, baseName: string, soft?: boolean): boolean; declare function couldBeBaseType(this: NodePath_Final, name: string): boolean; declare function baseTypeStrictlyMatches(this: NodePath_Final, rightArg: NodePath_Final): boolean; declare function isGenericType(this: NodePath_Final, genericName: string): boolean; declare function replaceWithMultiple>(this: NodePath_Final, nodes: Nodes): NodePaths; /** * Parse a string as an expression and replace the current node with the result. * * NOTE: This is typically not a good idea to use. Building source strings when * transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's * easier to use, your transforms will be extremely brittle. */ declare function replaceWithSourceString(this: NodePath_Final, replacement: string): [NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath>]; /** * Replace the current node with another. */ declare function replaceWith(this: NodePath_Final, replacementPath: R): [NodePath_Final]; declare function replaceWith>(this: NodePath_Final, replacementPath: R): [R]; /** * This method takes an array of statements nodes and then explodes it * into expressions. This method retains completion records which is * extremely important to retain original semantics. */ declare function replaceExpressionWithStatements(this: NodePath_Final, nodes: t.Statement[]): NodePath | (NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath>)[] | (NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath>)[]; declare function replaceInline(this: NodePath_Final, nodes: t.Node | t.Node[]): (NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath>)[]; /** * Walk the input `node` and statically evaluate if it's truthy. * * Returning `true` when we're sure that the expression will evaluate to a * truthy value, `false` if we're sure that it will evaluate to a falsy * value and `undefined` if we aren't sure. Because of this please do not * rely on coercion when using this method and check with === if it's false. * * For example do: * * if (t.evaluateTruthy(node) === false) falsyLogic(); * * **AND NOT** * * if (!t.evaluateTruthy(node)) falsyLogic(); * */ declare function evaluateTruthy(this: NodePath_Final): boolean | undefined; /** * Walk the input `node` and statically evaluate it. * * Returns an object in the form `{ confident, value, deopt }`. `confident` * indicates whether or not we had to drop out of evaluating the expression * because of hitting an unknown node that we couldn't confidently find the * value of, in which case `deopt` is the path of said node. * * Example: * * t.evaluate(parse("5 + 5")) // { confident: true, value: 10 } * t.evaluate(parse("!true")) // { confident: true, value: false } * t.evaluate(parse("foo + foo")) // { confident: false, value: undefined, deopt: NodePath } * */ declare function evaluate(this: NodePath_Final): { confident: boolean; value: any; deopt: NodePath_Final | null; }; declare function ensureBlock(this: NodePath_Final): void; /** * Given an arbitrary function, process its content as if it were an arrow function, moving references * to "this", "arguments", "super", and such into the function's parent scope. This method is useful if * you have wrapped some set of items in an IIFE or other function, but want "this", "arguments", and super" * to continue behaving as expected. */ declare function unwrapFunctionEnvironment(this: NodePath_Final): void; /** * Convert a given arrow function into a normal ES5 function expression. */ declare function arrowFunctionToExpression(this: NodePath_Final, { allowInsertArrow, allowInsertArrowWithRest, noNewArrows, }?: { allowInsertArrow?: boolean; allowInsertArrowWithRest?: boolean; noNewArrows?: boolean; }): NodePath_Final | t.CallExpression>; declare function splitExportDeclaration(this: NodePath_Final): NodePath_Final; declare function ensureFunctionName(this: NodePath_Final, supportUnicodeId: boolean): null | NodePath_Final; /** * Match the current node if it matches the provided `pattern`. * * For example, given the match `React.createClass` it would match the * parsed nodes of `React.createClass` and `React["createClass"]`. */ declare function matchesPattern(this: NodePath_Final, pattern: string, allowPartial?: boolean): boolean; declare function isStatic(this: NodePath_Final): boolean; /** * Check the type against our stored internal type of the node. This is handy when a node has * been removed yet we still internally know the type and need it to calculate node replacement. */ declare function isNodeType(this: NodePath_Final, type: string): boolean; /** * This checks whether or not we're in one of the following positions: * * for (KEY in right); * for (KEY;;); * * This is because these spots allow VariableDeclarations AND normal expressions so we need * to tell the path replacement that it's ok to replace this with an expression. */ declare function canHaveVariableDeclarationOrExpression(this: NodePath_Final): boolean; /** * This checks whether we are swapping an arrow function's body between an * expression and a block statement (or vice versa). * * This is because arrow functions may implicitly return an expression, which * is the same as containing a block statement. */ declare function canSwapBetweenExpressionAndStatement(this: NodePath_Final, replacement: t.Node): boolean; /** * Check whether the current path references a completion record */ declare function isCompletionRecord(this: NodePath_Final, allowInsideFunction?: boolean): boolean; /** * Check whether or not the current `key` allows either a single statement or block statement * so we can explode it if necessary. */ declare function isStatementOrBlock(this: NodePath_Final): boolean; /** * Check if the currently assigned path references the `importName` of `moduleSource`. */ declare function referencesImport(this: NodePath_Final, moduleSource: string, importName: string): boolean; /** * Get the source code associated with this node. */ declare function getSource(this: NodePath_Final): string; declare function willIMaybeExecuteBefore(this: NodePath_Final, target: NodePath_Final): boolean; type RelativeExecutionStatus = "before" | "after" | "unknown"; /** * Given a `target` check the execution status of it relative to the current path. * * "Execution status" simply refers to where or not we **think** this will execute * before or after the input `target` element. */ declare function _guessExecutionStatusRelativeTo(this: NodePath_Final, target: NodePath_Final): RelativeExecutionStatus; /** * Resolve the value pointed to by a NodePath * e.g. * ``` * var a = 1; * var b = a; * b; * ``` * `b.resolve()` will return `1` */ declare function resolve(this: NodePath_Final, dangerous?: boolean, resolved?: NodePath_Final[]): NodePath_Final; declare function isConstantExpression(this: NodePath_Final): boolean; declare function isInStrictMode(this: NodePath_Final): boolean; declare function isDenylisted(this: NodePath_Final): boolean; declare function skip(this: NodePath_Final): void; declare function skipKey(this: NodePath_Final, key: string): void; declare function stop(this: NodePath_Final): void; declare function setContext(this: NodePath_Final, context?: TraversalContext): NodePath_Final; declare function requeue(this: NodePath_Final, pathToQueue?: NodePath_Final): void; declare function requeueComputedKeyAndDecorators(this: NodePath_Final): void; declare function remove(this: NodePath_Final): void; /** * Insert the provided nodes before the current one. */ declare function insertBefore>(this: NodePath_Final, nodes_: Nodes): NodePaths; /** * Insert the provided nodes after the current one. When inserting nodes after an * expression, ensure that the completion record is correct by pushing the current node. */ declare function insertAfter>(this: NodePath_Final, nodes_: Nodes): NodePaths; type NodeKeyOfArrays = { [P in string & keyof N]-?: N[P] extends (t.Node | null)[] ? P : never; }[string & keyof N]; declare function unshiftContainer, Nodes extends NodeOrNodeList>>(this: NodePath_Final, listKey: K, nodes: Nodes): NodePaths; declare function pushContainer, Nodes extends NodeOrNodeList>>(this: NodePath_Final, listKey: K, nodes: Nodes): NodePaths; declare function getOpposite(this: NodePath_Final): NodePath_Final | null; /** * Retrieve the completion records of a given path. * Note: to ensure proper support on `break` statement, this method * will manipulate the AST around the break statement. Do not call the method * twice for the same path. * * @export * @param {NodePath} this * @param {boolean} [shouldPreserveBreak=false] Whether the `break` statement should be preserved. * @returns {NodePath[]} Completion records */ declare function getCompletionRecords(this: NodePath_Final, shouldPreserveBreak?: boolean): NodePath_Final[]; declare function getSibling(this: NodePath_Final, key: string | number): NodePath_Final; declare function getPrevSibling(this: NodePath_Final): NodePath_Final; declare function getNextSibling(this: NodePath_Final): NodePath_Final; declare function getAllNextSiblings(this: NodePath_Final): NodePath_Final[]; declare function getAllPrevSiblings(this: NodePath_Final): NodePath_Final[]; type MaybeToIndex = T extends `${number}` ? number : T; type Pattern = `${Obj}.${Prop}`; type Split

= P extends Pattern ? [MaybeToIndex, ...Split] : [MaybeToIndex

]; type Trav = Path extends [infer K, ...infer R] ? K extends keyof Node ? R extends [] ? Node[K] : Node[K] extends t.Node | t.Node[] | null | undefined ? null | undefined extends Node[K] ? TravD | null : TravD : never : string extends K ? t.Node | null : null : never; type TravD = Node extends any ? Trav : never; type ToNodePath = T extends undefined | null ? NodePath_Final : T extends (infer U extends t.Node | null)[] ? NodePath_Final[] : T extends t.Node | null | undefined ? NodePath_Final : never; declare function get(this: T, key: K, context?: true | TraversalContext): T extends any ? T["node"][K] extends (infer U extends t.Node | null)[] | null | undefined ? NodePath_Final[] : T["node"][K] extends (infer U extends t.Node | null) | undefined ? NodePath_Final : never : never; declare function get, K extends string>(this: T, key: K, context?: true | TraversalContext): string extends K ? NodePath_Final | NodePath_Final[] : T extends any ? ToNodePath>> : never; declare function get(this: NodePath_Final, key: string, context?: true | TraversalContext): NodePath_Final | NodePath_Final[]; declare function getAssignmentIdentifiers(this: NodePath_Final): Record; declare function getBindingIdentifiers(duplicates: true): Record; declare function getBindingIdentifiers(duplicates?: false): Record; declare function getBindingIdentifiers(duplicates: boolean): Record; declare function getOuterBindingIdentifiers(duplicates: true): Record; declare function getOuterBindingIdentifiers(duplicates?: false): Record; declare function getOuterBindingIdentifiers(duplicates: boolean): Record; declare function getBindingIdentifierPaths(duplicates: true, outerOnly?: boolean): Record[]>; declare function getBindingIdentifierPaths(duplicates: false, outerOnly?: boolean): Record>; declare function getBindingIdentifierPaths(duplicates?: boolean, outerOnly?: boolean): Record | NodePath_Final[]>; declare function getOuterBindingIdentifierPaths(duplicates: true): Record[]>; declare function getOuterBindingIdentifierPaths(duplicates?: false): Record>; declare function getOuterBindingIdentifierPaths(duplicates?: boolean): Record | NodePath_Final[]>; /** * Share comments amongst siblings. */ declare function shareCommentsWithSiblings(this: NodePath_Final): void; declare function addComment(this: NodePath_Final, type: t.CommentTypeShorthand, content: string, line?: boolean): void; /** * Give node `comments` of the specified `type`. */ declare function addComments(this: NodePath_Final, type: t.CommentTypeShorthand, comments: t.Comment[]): void; /* * This file is auto-generated! Do not modify it directly. * To re-generate run 'make build' */ type Options$2 = Partial<{ [Prop in Exclude]: Obj[Prop] extends t.Node ? t.Node : Obj[Prop] extends t.Node[] ? t.Node[] : Obj[Prop]; }>; interface NodePathAssertions { assertAccessor>( opts?: Opts, ): asserts this is NodePath_Final; assertAnyTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertArgumentPlaceholder>( opts?: Opts, ): asserts this is NodePath_Final; assertArrayExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertArrayPattern>( opts?: Opts, ): asserts this is NodePath_Final; assertArrayTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertArrowFunctionExpression< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertAssignmentExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertAssignmentPattern>( opts?: Opts, ): asserts this is NodePath_Final; assertAwaitExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertBigIntLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertBigIntLiteralTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertBinary>( opts?: Opts, ): asserts this is NodePath_Final; assertBinaryExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertBindExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertBlock>( opts?: Opts, ): asserts this is NodePath_Final; assertBlockParent>( opts?: Opts, ): asserts this is NodePath_Final; assertBlockStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertBooleanLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertBooleanLiteralTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertBooleanTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertBreakStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertCallExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertCatchClause>( opts?: Opts, ): asserts this is NodePath_Final; assertClass>( opts?: Opts, ): asserts this is NodePath_Final; assertClassAccessorProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertClassBody>( opts?: Opts, ): asserts this is NodePath_Final; assertClassDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertClassExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertClassImplements>( opts?: Opts, ): asserts this is NodePath_Final; assertClassMethod>( opts?: Opts, ): asserts this is NodePath_Final; assertClassPrivateMethod>( opts?: Opts, ): asserts this is NodePath_Final; assertClassPrivateProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertClassProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertCompletionStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertConditional>( opts?: Opts, ): asserts this is NodePath_Final; assertConditionalExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertContinueStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertDebuggerStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareClass>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareExportAllDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareExportDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareFunction>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareInterface>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareModule>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareModuleExports>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareOpaqueType>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareTypeAlias>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclareVariable>( opts?: Opts, ): asserts this is NodePath_Final; assertDeclaredPredicate>( opts?: Opts, ): asserts this is NodePath_Final; assertDecorator>( opts?: Opts, ): asserts this is NodePath_Final; assertDirective>( opts?: Opts, ): asserts this is NodePath_Final; assertDirectiveLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertDoExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertDoWhileStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertEmptyStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertEmptyTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumBody>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumBooleanBody>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumBooleanMember>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumDefaultedMember>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumMember>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumNumberBody>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumNumberMember>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumStringBody>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumStringMember>( opts?: Opts, ): asserts this is NodePath_Final; assertEnumSymbolBody>( opts?: Opts, ): asserts this is NodePath_Final; assertExistsTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertExportAllDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertExportDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertExportDefaultDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertExportDefaultSpecifier>( opts?: Opts, ): asserts this is NodePath_Final; assertExportNamedDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertExportNamespaceSpecifier< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertExportSpecifier>( opts?: Opts, ): asserts this is NodePath_Final; assertExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertExpressionStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertExpressionWrapper>( opts?: Opts, ): asserts this is NodePath_Final; assertFile>( opts?: Opts, ): asserts this is NodePath_Final; assertFlow>( opts?: Opts, ): asserts this is NodePath_Final; assertFlowBaseAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertFlowDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertFlowPredicate>( opts?: Opts, ): asserts this is NodePath_Final; assertFlowType>( opts?: Opts, ): asserts this is NodePath_Final; assertFor>( opts?: Opts, ): asserts this is NodePath_Final; assertForInStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertForOfStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertForStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertForXStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertFunction>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionParameter>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionParent>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertFunctionTypeParam>( opts?: Opts, ): asserts this is NodePath_Final; assertGenericTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertIdentifier>( opts?: Opts, ): asserts this is NodePath_Final; assertIfStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertImmutable>( opts?: Opts, ): asserts this is NodePath_Final; assertImport>( opts?: Opts, ): asserts this is NodePath_Final; assertImportAttribute>( opts?: Opts, ): asserts this is NodePath_Final; assertImportDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertImportDefaultSpecifier>( opts?: Opts, ): asserts this is NodePath_Final; assertImportExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertImportNamespaceSpecifier< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertImportOrExportDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertImportSpecifier>( opts?: Opts, ): asserts this is NodePath_Final; assertIndexedAccessType>( opts?: Opts, ): asserts this is NodePath_Final; assertInferredPredicate>( opts?: Opts, ): asserts this is NodePath_Final; assertInterfaceDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertInterfaceExtends>( opts?: Opts, ): asserts this is NodePath_Final; assertInterfaceTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertInterpreterDirective>( opts?: Opts, ): asserts this is NodePath_Final; assertIntersectionTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertJSX>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXAttribute>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXClosingElement>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXClosingFragment>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXElement>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXEmptyExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXExpressionContainer>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXFragment>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXIdentifier>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXMemberExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXNamespacedName>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXOpeningElement>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXOpeningFragment>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXSpreadAttribute>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXSpreadChild>( opts?: Opts, ): asserts this is NodePath_Final; assertJSXText>( opts?: Opts, ): asserts this is NodePath_Final; assertLVal>( opts?: Opts, ): asserts this is NodePath_Final; assertLabeledStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertLogicalExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertLoop>( opts?: Opts, ): asserts this is NodePath_Final; assertMemberExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertMetaProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertMethod>( opts?: Opts, ): asserts this is NodePath_Final; assertMiscellaneous>( opts?: Opts, ): asserts this is NodePath_Final; assertMixedTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertModuleDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertModuleExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertModuleSpecifier>( opts?: Opts, ): asserts this is NodePath_Final; assertNewExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertNullLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertNullLiteralTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertNullableTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertNumberLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertNumberLiteralTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertNumberTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertNumericLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectMember>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectMethod>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectPattern>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeCallProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeIndexer>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeInternalSlot>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertObjectTypeSpreadProperty< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertOpaqueType>( opts?: Opts, ): asserts this is NodePath_Final; assertOptionalCallExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertOptionalIndexedAccessType< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertOptionalMemberExpression< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertParenthesizedExpression< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertPattern>( opts?: Opts, ): asserts this is NodePath_Final; assertPatternLike>( opts?: Opts, ): asserts this is NodePath_Final; assertPlaceholder>( opts?: Opts, ): asserts this is NodePath_Final; assertPrivate>( opts?: Opts, ): asserts this is NodePath_Final; assertPrivateName>( opts?: Opts, ): asserts this is NodePath_Final; assertProgram>( opts?: Opts, ): asserts this is NodePath_Final; assertProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertPureish>( opts?: Opts, ): asserts this is NodePath_Final; assertQualifiedTypeIdentifier< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertRegExpLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertRegexLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertRestElement>( opts?: Opts, ): asserts this is NodePath_Final; assertRestProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertReturnStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertScopable>( opts?: Opts, ): asserts this is NodePath_Final; assertSequenceExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertSpreadElement>( opts?: Opts, ): asserts this is NodePath_Final; assertSpreadProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertStandardized>( opts?: Opts, ): asserts this is NodePath_Final; assertStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertStaticBlock>( opts?: Opts, ): asserts this is NodePath_Final; assertStringLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertStringLiteralTypeAnnotation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertStringTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertSuper>( opts?: Opts, ): asserts this is NodePath_Final; assertSwitchCase>( opts?: Opts, ): asserts this is NodePath_Final; assertSwitchStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertSymbolTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertTSAnyKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSArrayType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSAsExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertTSBaseType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSBigIntKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSBooleanKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSCallSignatureDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSClassImplements>( opts?: Opts, ): asserts this is NodePath_Final; assertTSConditionalType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSConstructSignatureDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSConstructorType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSDeclareFunction>( opts?: Opts, ): asserts this is NodePath_Final; assertTSDeclareMethod>( opts?: Opts, ): asserts this is NodePath_Final; assertTSEntityName>( opts?: Opts, ): asserts this is NodePath_Final; assertTSEnumBody>( opts?: Opts, ): asserts this is NodePath_Final; assertTSEnumDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertTSEnumMember>( opts?: Opts, ): asserts this is NodePath_Final; assertTSExportAssignment>( opts?: Opts, ): asserts this is NodePath_Final; assertTSExternalModuleReference< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSFunctionType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSImportEqualsDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSImportType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSIndexSignature>( opts?: Opts, ): asserts this is NodePath_Final; assertTSIndexedAccessType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSInferType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSInstantiationExpression< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSInterfaceBody>( opts?: Opts, ): asserts this is NodePath_Final; assertTSInterfaceDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertTSInterfaceHeritage>( opts?: Opts, ): asserts this is NodePath_Final; assertTSIntersectionType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSIntrinsicKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSLiteralType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSMappedType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSMethodSignature>( opts?: Opts, ): asserts this is NodePath_Final; assertTSModuleBlock>( opts?: Opts, ): asserts this is NodePath_Final; assertTSModuleDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertTSNamedTupleMember>( opts?: Opts, ): asserts this is NodePath_Final; assertTSNamespaceExportDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSNeverKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSNonNullExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertTSNullKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSNumberKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSObjectKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSOptionalType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSParameterProperty>( opts?: Opts, ): asserts this is NodePath_Final; assertTSParenthesizedType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSPropertySignature>( opts?: Opts, ): asserts this is NodePath_Final; assertTSQualifiedName>( opts?: Opts, ): asserts this is NodePath_Final; assertTSRestType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSSatisfiesExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertTSStringKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSSymbolKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTemplateLiteralType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSThisType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTupleType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeAliasDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeAssertion>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeElement>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeOperator>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeParameter>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeParameterDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeParameterInstantiation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypePredicate>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeQuery>( opts?: Opts, ): asserts this is NodePath_Final; assertTSTypeReference>( opts?: Opts, ): asserts this is NodePath_Final; assertTSUndefinedKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSUnionType>( opts?: Opts, ): asserts this is NodePath_Final; assertTSUnknownKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTSVoidKeyword>( opts?: Opts, ): asserts this is NodePath_Final; assertTaggedTemplateExpression< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTemplateElement>( opts?: Opts, ): asserts this is NodePath_Final; assertTemplateLiteral>( opts?: Opts, ): asserts this is NodePath_Final; assertTerminatorless>( opts?: Opts, ): asserts this is NodePath_Final; assertThisExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertThisTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertThrowStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertTopicReference>( opts?: Opts, ): asserts this is NodePath_Final; assertTryStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertTupleTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeAlias>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeCastExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeParameter>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeParameterDeclaration< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTypeParameterInstantiation< Opts extends Options$2, >( opts?: Opts, ): asserts this is NodePath_Final; assertTypeScript>( opts?: Opts, ): asserts this is NodePath_Final; assertTypeofTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertUnaryExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertUnaryLike>( opts?: Opts, ): asserts this is NodePath_Final; assertUnionTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertUpdateExpression>( opts?: Opts, ): asserts this is NodePath_Final; assertUserWhitespacable>( opts?: Opts, ): asserts this is NodePath_Final; assertV8IntrinsicIdentifier>( opts?: Opts, ): asserts this is NodePath_Final; assertVariableDeclaration>( opts?: Opts, ): asserts this is NodePath_Final; assertVariableDeclarator>( opts?: Opts, ): asserts this is NodePath_Final; assertVariance>( opts?: Opts, ): asserts this is NodePath_Final; assertVoidPattern>( opts?: Opts, ): asserts this is NodePath_Final; assertVoidTypeAnnotation>( opts?: Opts, ): asserts this is NodePath_Final; assertWhile>( opts?: Opts, ): asserts this is NodePath_Final; assertWhileStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertWithStatement>( opts?: Opts, ): asserts this is NodePath_Final; assertYieldExpression>( opts?: Opts, ): asserts this is NodePath_Final; } type Options$1 = Partial<{ [Prop in Exclude]: Obj[Prop] extends t.Node ? t.Node : Obj[Prop] extends t.Node[] ? t.Node[] : Obj[Prop]; }>; interface VirtualTypeNodePathValidators { isBindingIdentifier(this: NodePath_Final): this is NodePath_Final; isBlockScoped(this: NodePath_Final): boolean; /** * @deprecated */ isExistentialTypeParam(this: NodePath_Final): this is NodePath_Final; isExpression(this: NodePath_Final): this is NodePath_Final; isFlow(this: NodePath_Final): this is NodePath_Final; isForAwaitStatement(this: NodePath_Final): this is NodePath_Final; isGenerated(this: NodePath_Final): this is NodePath_Final; /** * @deprecated */ isNumericLiteralTypeAnnotation(this: NodePath_Final): void; isPure(): boolean; isReferenced(): boolean; isReferencedIdentifier>(this: NodePath_Final, opts?: Opts): this is NodePath_Final; isReferencedMemberExpression(this: NodePath_Final): this is NodePath_Final; isRestProperty(this: NodePath_Final): this is NodePath_Final; isScope(this: NodePath_Final): this is NodePath_Final; isSpreadProperty(this: NodePath_Final): this is NodePath_Final; isStatement(this: NodePath_Final): this is NodePath_Final; isUser(this: NodePath_Final): this is NodePath_Final; isVar(this: NodePath_Final): this is NodePath_Final; } /* * This file is auto-generated! Do not modify it directly. * To re-generate run 'make build' */ type Options = Partial<{ [Prop in Exclude]: Obj[Prop] extends t.Node ? t.Node : Obj[Prop] extends t.Node[] ? t.Node[] : Obj[Prop]; }>; interface BaseNodePathValidators { isAccessor(this: NodePath_Final): this is NodePath_Final; isAccessor>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isAnyTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isAnyTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isArgumentPlaceholder( this: NodePath_Final, ): this is NodePath_Final; isArgumentPlaceholder>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isArrayExpression( this: NodePath_Final, ): this is NodePath_Final; isArrayExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isArrayPattern( this: NodePath_Final, ): this is NodePath_Final; isArrayPattern>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isArrayTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isArrayTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isArrowFunctionExpression( this: NodePath_Final, ): this is NodePath_Final; isArrowFunctionExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isAssignmentExpression( this: NodePath_Final, ): this is NodePath_Final; isAssignmentExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isAssignmentPattern( this: NodePath_Final, ): this is NodePath_Final; isAssignmentPattern>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isAwaitExpression( this: NodePath_Final, ): this is NodePath_Final; isAwaitExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBigIntLiteral( this: NodePath_Final, ): this is NodePath_Final; isBigIntLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBigIntLiteralTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isBigIntLiteralTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBinary(this: NodePath_Final): this is NodePath_Final; isBinary>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBinaryExpression( this: NodePath_Final, ): this is NodePath_Final; isBinaryExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBindExpression( this: NodePath_Final, ): this is NodePath_Final; isBindExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBlock(this: NodePath_Final): this is NodePath_Final; isBlock>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBlockParent(this: NodePath_Final): this is NodePath_Final; isBlockParent>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBlockStatement( this: NodePath_Final, ): this is NodePath_Final; isBlockStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBooleanLiteral( this: NodePath_Final, ): this is NodePath_Final; isBooleanLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBooleanLiteralTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isBooleanLiteralTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBooleanTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isBooleanTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isBreakStatement( this: NodePath_Final, ): this is NodePath_Final; isBreakStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isCallExpression( this: NodePath_Final, ): this is NodePath_Final; isCallExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isCatchClause(this: NodePath_Final): this is NodePath_Final; isCatchClause>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClass(this: NodePath_Final): this is NodePath_Final; isClass>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassAccessorProperty( this: NodePath_Final, ): this is NodePath_Final; isClassAccessorProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassBody(this: NodePath_Final): this is NodePath_Final; isClassBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassDeclaration( this: NodePath_Final, ): this is NodePath_Final; isClassDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassExpression( this: NodePath_Final, ): this is NodePath_Final; isClassExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassImplements( this: NodePath_Final, ): this is NodePath_Final; isClassImplements>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassMethod(this: NodePath_Final): this is NodePath_Final; isClassMethod>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassPrivateMethod( this: NodePath_Final, ): this is NodePath_Final; isClassPrivateMethod>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassPrivateProperty( this: NodePath_Final, ): this is NodePath_Final; isClassPrivateProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isClassProperty( this: NodePath_Final, ): this is NodePath_Final; isClassProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isCompletionStatement( this: NodePath_Final, ): this is NodePath_Final; isCompletionStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isConditional(this: NodePath_Final): this is NodePath_Final; isConditional>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isConditionalExpression( this: NodePath_Final, ): this is NodePath_Final; isConditionalExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isContinueStatement( this: NodePath_Final, ): this is NodePath_Final; isContinueStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDebuggerStatement( this: NodePath_Final, ): this is NodePath_Final; isDebuggerStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclaration(this: NodePath_Final): this is NodePath_Final; isDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareClass( this: NodePath_Final, ): this is NodePath_Final; isDeclareClass>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareExportAllDeclaration( this: NodePath_Final, ): this is NodePath_Final; isDeclareExportAllDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareExportDeclaration( this: NodePath_Final, ): this is NodePath_Final; isDeclareExportDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareFunction( this: NodePath_Final, ): this is NodePath_Final; isDeclareFunction>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareInterface( this: NodePath_Final, ): this is NodePath_Final; isDeclareInterface>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareModule( this: NodePath_Final, ): this is NodePath_Final; isDeclareModule>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareModuleExports( this: NodePath_Final, ): this is NodePath_Final; isDeclareModuleExports>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareOpaqueType( this: NodePath_Final, ): this is NodePath_Final; isDeclareOpaqueType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareTypeAlias( this: NodePath_Final, ): this is NodePath_Final; isDeclareTypeAlias>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclareVariable( this: NodePath_Final, ): this is NodePath_Final; isDeclareVariable>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDeclaredPredicate( this: NodePath_Final, ): this is NodePath_Final; isDeclaredPredicate>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDecorator(this: NodePath_Final): this is NodePath_Final; isDecorator>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDirective(this: NodePath_Final): this is NodePath_Final; isDirective>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDirectiveLiteral( this: NodePath_Final, ): this is NodePath_Final; isDirectiveLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDoExpression( this: NodePath_Final, ): this is NodePath_Final; isDoExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isDoWhileStatement( this: NodePath_Final, ): this is NodePath_Final; isDoWhileStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEmptyStatement( this: NodePath_Final, ): this is NodePath_Final; isEmptyStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEmptyTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isEmptyTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumBody(this: NodePath_Final): this is NodePath_Final; isEnumBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumBooleanBody( this: NodePath_Final, ): this is NodePath_Final; isEnumBooleanBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumBooleanMember( this: NodePath_Final, ): this is NodePath_Final; isEnumBooleanMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumDeclaration( this: NodePath_Final, ): this is NodePath_Final; isEnumDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumDefaultedMember( this: NodePath_Final, ): this is NodePath_Final; isEnumDefaultedMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumMember(this: NodePath_Final): this is NodePath_Final; isEnumMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumNumberBody( this: NodePath_Final, ): this is NodePath_Final; isEnumNumberBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumNumberMember( this: NodePath_Final, ): this is NodePath_Final; isEnumNumberMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumStringBody( this: NodePath_Final, ): this is NodePath_Final; isEnumStringBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumStringMember( this: NodePath_Final, ): this is NodePath_Final; isEnumStringMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isEnumSymbolBody( this: NodePath_Final, ): this is NodePath_Final; isEnumSymbolBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExistsTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isExistsTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportAllDeclaration( this: NodePath_Final, ): this is NodePath_Final; isExportAllDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportDeclaration( this: NodePath_Final, ): this is NodePath_Final; isExportDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportDefaultDeclaration( this: NodePath_Final, ): this is NodePath_Final; isExportDefaultDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportDefaultSpecifier( this: NodePath_Final, ): this is NodePath_Final; isExportDefaultSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportNamedDeclaration( this: NodePath_Final, ): this is NodePath_Final; isExportNamedDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportNamespaceSpecifier( this: NodePath_Final, ): this is NodePath_Final; isExportNamespaceSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExportSpecifier( this: NodePath_Final, ): this is NodePath_Final; isExportSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExpression(this: NodePath_Final): this is NodePath_Final; isExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExpressionStatement( this: NodePath_Final, ): this is NodePath_Final; isExpressionStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isExpressionWrapper( this: NodePath_Final, ): this is NodePath_Final; isExpressionWrapper>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFile(this: NodePath_Final): this is NodePath_Final; isFile>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFlow(this: NodePath_Final): this is NodePath_Final; isFlow>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFlowBaseAnnotation( this: NodePath_Final, ): this is NodePath_Final; isFlowBaseAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFlowDeclaration( this: NodePath_Final, ): this is NodePath_Final; isFlowDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFlowPredicate( this: NodePath_Final, ): this is NodePath_Final; isFlowPredicate>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFlowType(this: NodePath_Final): this is NodePath_Final; isFlowType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFor(this: NodePath_Final): this is NodePath_Final; isFor>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isForInStatement( this: NodePath_Final, ): this is NodePath_Final; isForInStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isForOfStatement( this: NodePath_Final, ): this is NodePath_Final; isForOfStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isForStatement( this: NodePath_Final, ): this is NodePath_Final; isForStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isForXStatement( this: NodePath_Final, ): this is NodePath_Final; isForXStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunction(this: NodePath_Final): this is NodePath_Final; isFunction>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionDeclaration( this: NodePath_Final, ): this is NodePath_Final; isFunctionDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionExpression( this: NodePath_Final, ): this is NodePath_Final; isFunctionExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionParameter( this: NodePath_Final, ): this is NodePath_Final; isFunctionParameter>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionParent( this: NodePath_Final, ): this is NodePath_Final; isFunctionParent>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isFunctionTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isFunctionTypeParam( this: NodePath_Final, ): this is NodePath_Final; isFunctionTypeParam>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isGenericTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isGenericTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isIdentifier(this: NodePath_Final): this is NodePath_Final; isIdentifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isIfStatement(this: NodePath_Final): this is NodePath_Final; isIfStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImmutable(this: NodePath_Final): this is NodePath_Final; isImmutable>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImport(this: NodePath_Final): this is NodePath_Final; isImport>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportAttribute( this: NodePath_Final, ): this is NodePath_Final; isImportAttribute>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportDeclaration( this: NodePath_Final, ): this is NodePath_Final; isImportDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportDefaultSpecifier( this: NodePath_Final, ): this is NodePath_Final; isImportDefaultSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportExpression( this: NodePath_Final, ): this is NodePath_Final; isImportExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportNamespaceSpecifier( this: NodePath_Final, ): this is NodePath_Final; isImportNamespaceSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportOrExportDeclaration( this: NodePath_Final, ): this is NodePath_Final; isImportOrExportDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isImportSpecifier( this: NodePath_Final, ): this is NodePath_Final; isImportSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isIndexedAccessType( this: NodePath_Final, ): this is NodePath_Final; isIndexedAccessType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isInferredPredicate( this: NodePath_Final, ): this is NodePath_Final; isInferredPredicate>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isInterfaceDeclaration( this: NodePath_Final, ): this is NodePath_Final; isInterfaceDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isInterfaceExtends( this: NodePath_Final, ): this is NodePath_Final; isInterfaceExtends>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isInterfaceTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isInterfaceTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isInterpreterDirective( this: NodePath_Final, ): this is NodePath_Final; isInterpreterDirective>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isIntersectionTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isIntersectionTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSX(this: NodePath_Final): this is NodePath_Final; isJSX>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXAttribute( this: NodePath_Final, ): this is NodePath_Final; isJSXAttribute>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXClosingElement( this: NodePath_Final, ): this is NodePath_Final; isJSXClosingElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXClosingFragment( this: NodePath_Final, ): this is NodePath_Final; isJSXClosingFragment>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXElement(this: NodePath_Final): this is NodePath_Final; isJSXElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXEmptyExpression( this: NodePath_Final, ): this is NodePath_Final; isJSXEmptyExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXExpressionContainer( this: NodePath_Final, ): this is NodePath_Final; isJSXExpressionContainer>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXFragment(this: NodePath_Final): this is NodePath_Final; isJSXFragment>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXIdentifier( this: NodePath_Final, ): this is NodePath_Final; isJSXIdentifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXMemberExpression( this: NodePath_Final, ): this is NodePath_Final; isJSXMemberExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXNamespacedName( this: NodePath_Final, ): this is NodePath_Final; isJSXNamespacedName>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXOpeningElement( this: NodePath_Final, ): this is NodePath_Final; isJSXOpeningElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXOpeningFragment( this: NodePath_Final, ): this is NodePath_Final; isJSXOpeningFragment>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXSpreadAttribute( this: NodePath_Final, ): this is NodePath_Final; isJSXSpreadAttribute>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXSpreadChild( this: NodePath_Final, ): this is NodePath_Final; isJSXSpreadChild>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isJSXText(this: NodePath_Final): this is NodePath_Final; isJSXText>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isLVal(this: NodePath_Final): this is NodePath_Final; isLVal>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isLabeledStatement( this: NodePath_Final, ): this is NodePath_Final; isLabeledStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isLiteral(this: NodePath_Final): this is NodePath_Final; isLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isLogicalExpression( this: NodePath_Final, ): this is NodePath_Final; isLogicalExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isLoop(this: NodePath_Final): this is NodePath_Final; isLoop>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isMemberExpression( this: NodePath_Final, ): this is NodePath_Final; isMemberExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isMetaProperty( this: NodePath_Final, ): this is NodePath_Final; isMetaProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isMethod(this: NodePath_Final): this is NodePath_Final; isMethod>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isMiscellaneous( this: NodePath_Final, ): this is NodePath_Final; isMiscellaneous>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isMixedTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isMixedTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isModuleDeclaration( this: NodePath_Final, ): this is NodePath_Final; isModuleDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isModuleExpression( this: NodePath_Final, ): this is NodePath_Final; isModuleExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isModuleSpecifier( this: NodePath_Final, ): this is NodePath_Final; isModuleSpecifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNewExpression( this: NodePath_Final, ): this is NodePath_Final; isNewExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNullLiteral(this: NodePath_Final): this is NodePath_Final; isNullLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNullLiteralTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isNullLiteralTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNullableTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isNullableTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNumberLiteral( this: NodePath_Final, ): this is NodePath_Final; isNumberLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNumberLiteralTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isNumberLiteralTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNumberTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isNumberTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isNumericLiteral( this: NodePath_Final, ): this is NodePath_Final; isNumericLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectExpression( this: NodePath_Final, ): this is NodePath_Final; isObjectExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectMember( this: NodePath_Final, ): this is NodePath_Final; isObjectMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectMethod( this: NodePath_Final, ): this is NodePath_Final; isObjectMethod>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectPattern( this: NodePath_Final, ): this is NodePath_Final; isObjectPattern>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectProperty( this: NodePath_Final, ): this is NodePath_Final; isObjectProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeCallProperty( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeCallProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeIndexer( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeIndexer>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeInternalSlot( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeInternalSlot>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeProperty( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isObjectTypeSpreadProperty( this: NodePath_Final, ): this is NodePath_Final; isObjectTypeSpreadProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isOpaqueType(this: NodePath_Final): this is NodePath_Final; isOpaqueType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isOptionalCallExpression( this: NodePath_Final, ): this is NodePath_Final; isOptionalCallExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isOptionalIndexedAccessType( this: NodePath_Final, ): this is NodePath_Final; isOptionalIndexedAccessType< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isOptionalMemberExpression( this: NodePath_Final, ): this is NodePath_Final; isOptionalMemberExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isParenthesizedExpression( this: NodePath_Final, ): this is NodePath_Final; isParenthesizedExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPattern(this: NodePath_Final): this is NodePath_Final; isPattern>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPatternLike(this: NodePath_Final): this is NodePath_Final; isPatternLike>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPlaceholder(this: NodePath_Final): this is NodePath_Final; isPlaceholder>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPrivate(this: NodePath_Final): this is NodePath_Final; isPrivate>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPrivateName(this: NodePath_Final): this is NodePath_Final; isPrivateName>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isProgram(this: NodePath_Final): this is NodePath_Final; isProgram>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isProperty(this: NodePath_Final): this is NodePath_Final; isProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isPureish(this: NodePath_Final): this is NodePath_Final; isPureish>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isQualifiedTypeIdentifier( this: NodePath_Final, ): this is NodePath_Final; isQualifiedTypeIdentifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isRegExpLiteral( this: NodePath_Final, ): this is NodePath_Final; isRegExpLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isRegexLiteral( this: NodePath_Final, ): this is NodePath_Final; isRegexLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isRestElement(this: NodePath_Final): this is NodePath_Final; isRestElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isRestProperty( this: NodePath_Final, ): this is NodePath_Final; isRestProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isReturnStatement( this: NodePath_Final, ): this is NodePath_Final; isReturnStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isScopable(this: NodePath_Final): this is NodePath_Final; isScopable>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSequenceExpression( this: NodePath_Final, ): this is NodePath_Final; isSequenceExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSpreadElement( this: NodePath_Final, ): this is NodePath_Final; isSpreadElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSpreadProperty( this: NodePath_Final, ): this is NodePath_Final; isSpreadProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStandardized( this: NodePath_Final, ): this is NodePath_Final; isStandardized>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStatement(this: NodePath_Final): this is NodePath_Final; isStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStaticBlock(this: NodePath_Final): this is NodePath_Final; isStaticBlock>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStringLiteral( this: NodePath_Final, ): this is NodePath_Final; isStringLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStringLiteralTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isStringLiteralTypeAnnotation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isStringTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isStringTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSuper(this: NodePath_Final): this is NodePath_Final; isSuper>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSwitchCase(this: NodePath_Final): this is NodePath_Final; isSwitchCase>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSwitchStatement( this: NodePath_Final, ): this is NodePath_Final; isSwitchStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isSymbolTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isSymbolTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSAnyKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSAnyKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSArrayType(this: NodePath_Final): this is NodePath_Final; isTSArrayType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSAsExpression( this: NodePath_Final, ): this is NodePath_Final; isTSAsExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSBaseType(this: NodePath_Final): this is NodePath_Final; isTSBaseType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSBigIntKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSBigIntKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSBooleanKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSBooleanKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSCallSignatureDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSCallSignatureDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSClassImplements( this: NodePath_Final, ): this is NodePath_Final; isTSClassImplements>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSConditionalType( this: NodePath_Final, ): this is NodePath_Final; isTSConditionalType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSConstructSignatureDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSConstructSignatureDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSConstructorType( this: NodePath_Final, ): this is NodePath_Final; isTSConstructorType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSDeclareFunction( this: NodePath_Final, ): this is NodePath_Final; isTSDeclareFunction>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSDeclareMethod( this: NodePath_Final, ): this is NodePath_Final; isTSDeclareMethod>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSEntityName( this: NodePath_Final, ): this is NodePath_Final; isTSEntityName>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSEnumBody(this: NodePath_Final): this is NodePath_Final; isTSEnumBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSEnumDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSEnumDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSEnumMember( this: NodePath_Final, ): this is NodePath_Final; isTSEnumMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSExportAssignment( this: NodePath_Final, ): this is NodePath_Final; isTSExportAssignment>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSExternalModuleReference( this: NodePath_Final, ): this is NodePath_Final; isTSExternalModuleReference< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSFunctionType( this: NodePath_Final, ): this is NodePath_Final; isTSFunctionType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSImportEqualsDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSImportEqualsDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSImportType( this: NodePath_Final, ): this is NodePath_Final; isTSImportType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSIndexSignature( this: NodePath_Final, ): this is NodePath_Final; isTSIndexSignature>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSIndexedAccessType( this: NodePath_Final, ): this is NodePath_Final; isTSIndexedAccessType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSInferType(this: NodePath_Final): this is NodePath_Final; isTSInferType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSInstantiationExpression( this: NodePath_Final, ): this is NodePath_Final; isTSInstantiationExpression< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSInterfaceBody( this: NodePath_Final, ): this is NodePath_Final; isTSInterfaceBody>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSInterfaceDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSInterfaceDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSInterfaceHeritage( this: NodePath_Final, ): this is NodePath_Final; isTSInterfaceHeritage>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSIntersectionType( this: NodePath_Final, ): this is NodePath_Final; isTSIntersectionType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSIntrinsicKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSIntrinsicKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSLiteralType( this: NodePath_Final, ): this is NodePath_Final; isTSLiteralType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSMappedType( this: NodePath_Final, ): this is NodePath_Final; isTSMappedType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSMethodSignature( this: NodePath_Final, ): this is NodePath_Final; isTSMethodSignature>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSModuleBlock( this: NodePath_Final, ): this is NodePath_Final; isTSModuleBlock>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSModuleDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSModuleDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNamedTupleMember( this: NodePath_Final, ): this is NodePath_Final; isTSNamedTupleMember>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNamespaceExportDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSNamespaceExportDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNeverKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSNeverKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNonNullExpression( this: NodePath_Final, ): this is NodePath_Final; isTSNonNullExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNullKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSNullKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSNumberKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSNumberKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSObjectKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSObjectKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSOptionalType( this: NodePath_Final, ): this is NodePath_Final; isTSOptionalType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSParameterProperty( this: NodePath_Final, ): this is NodePath_Final; isTSParameterProperty>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSParenthesizedType( this: NodePath_Final, ): this is NodePath_Final; isTSParenthesizedType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSPropertySignature( this: NodePath_Final, ): this is NodePath_Final; isTSPropertySignature>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSQualifiedName( this: NodePath_Final, ): this is NodePath_Final; isTSQualifiedName>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSRestType(this: NodePath_Final): this is NodePath_Final; isTSRestType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSSatisfiesExpression( this: NodePath_Final, ): this is NodePath_Final; isTSSatisfiesExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSStringKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSStringKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSSymbolKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSSymbolKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTemplateLiteralType( this: NodePath_Final, ): this is NodePath_Final; isTSTemplateLiteralType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSThisType(this: NodePath_Final): this is NodePath_Final; isTSThisType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTupleType(this: NodePath_Final): this is NodePath_Final; isTSTupleType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSType(this: NodePath_Final): this is NodePath_Final; isTSType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeAliasDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSTypeAliasDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isTSTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeAssertion( this: NodePath_Final, ): this is NodePath_Final; isTSTypeAssertion>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeElement( this: NodePath_Final, ): this is NodePath_Final; isTSTypeElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeLiteral( this: NodePath_Final, ): this is NodePath_Final; isTSTypeLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeOperator( this: NodePath_Final, ): this is NodePath_Final; isTSTypeOperator>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeParameter( this: NodePath_Final, ): this is NodePath_Final; isTSTypeParameter>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeParameterDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTSTypeParameterDeclaration< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeParameterInstantiation( this: NodePath_Final, ): this is NodePath_Final; isTSTypeParameterInstantiation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypePredicate( this: NodePath_Final, ): this is NodePath_Final; isTSTypePredicate>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeQuery(this: NodePath_Final): this is NodePath_Final; isTSTypeQuery>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSTypeReference( this: NodePath_Final, ): this is NodePath_Final; isTSTypeReference>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSUndefinedKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSUndefinedKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSUnionType(this: NodePath_Final): this is NodePath_Final; isTSUnionType>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSUnknownKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSUnknownKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTSVoidKeyword( this: NodePath_Final, ): this is NodePath_Final; isTSVoidKeyword>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTaggedTemplateExpression( this: NodePath_Final, ): this is NodePath_Final; isTaggedTemplateExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTemplateElement( this: NodePath_Final, ): this is NodePath_Final; isTemplateElement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTemplateLiteral( this: NodePath_Final, ): this is NodePath_Final; isTemplateLiteral>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTerminatorless( this: NodePath_Final, ): this is NodePath_Final; isTerminatorless>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isThisExpression( this: NodePath_Final, ): this is NodePath_Final; isThisExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isThisTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isThisTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isThrowStatement( this: NodePath_Final, ): this is NodePath_Final; isThrowStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTopicReference( this: NodePath_Final, ): this is NodePath_Final; isTopicReference>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTryStatement( this: NodePath_Final, ): this is NodePath_Final; isTryStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTupleTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isTupleTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeAlias(this: NodePath_Final): this is NodePath_Final; isTypeAlias>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeCastExpression( this: NodePath_Final, ): this is NodePath_Final; isTypeCastExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeParameter( this: NodePath_Final, ): this is NodePath_Final; isTypeParameter>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeParameterDeclaration( this: NodePath_Final, ): this is NodePath_Final; isTypeParameterDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeParameterInstantiation( this: NodePath_Final, ): this is NodePath_Final; isTypeParameterInstantiation< Opts extends Options, >( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeScript(this: NodePath_Final): this is NodePath_Final; isTypeScript>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isTypeofTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isTypeofTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isUnaryExpression( this: NodePath_Final, ): this is NodePath_Final; isUnaryExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isUnaryLike(this: NodePath_Final): this is NodePath_Final; isUnaryLike>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isUnionTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isUnionTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isUpdateExpression( this: NodePath_Final, ): this is NodePath_Final; isUpdateExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isUserWhitespacable( this: NodePath_Final, ): this is NodePath_Final; isUserWhitespacable>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isV8IntrinsicIdentifier( this: NodePath_Final, ): this is NodePath_Final; isV8IntrinsicIdentifier>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isVariableDeclaration( this: NodePath_Final, ): this is NodePath_Final; isVariableDeclaration>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isVariableDeclarator( this: NodePath_Final, ): this is NodePath_Final; isVariableDeclarator>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isVariance(this: NodePath_Final): this is NodePath_Final; isVariance>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isVoidPattern(this: NodePath_Final): this is NodePath_Final; isVoidPattern>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isVoidTypeAnnotation( this: NodePath_Final, ): this is NodePath_Final; isVoidTypeAnnotation>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isWhile(this: NodePath_Final): this is NodePath_Final; isWhile>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isWhileStatement( this: NodePath_Final, ): this is NodePath_Final; isWhileStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isWithStatement( this: NodePath_Final, ): this is NodePath_Final; isWithStatement>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; isYieldExpression( this: NodePath_Final, ): this is NodePath_Final; isYieldExpression>( this: NodePath_Final, opts: Opts, ): this is NodePath_Final; } interface NodePathValidators extends Omit, VirtualTypeNodePathValidators {} type NodePaths = T extends t.Node[] ? { [K in keyof T]: NodePath_Final>; } : T extends t.Node ? [NodePath_Final] : never; type NodeListType = N[K] extends (infer P extends t.Node)[] ? P : never; type NodeOrNodeList = T | NodeList; type NodeList = T[] | [T, ...T[]]; declare const methods: { findParent: typeof findParent; find: typeof find; getFunctionParent: typeof getFunctionParent; getStatementParent: typeof getStatementParent; getEarliestCommonAncestorFrom: typeof getEarliestCommonAncestorFrom; getDeepestCommonAncestorFrom: typeof getDeepestCommonAncestorFrom; getAncestry: typeof getAncestry; isAncestor: typeof isAncestor; isDescendant: typeof isDescendant; inType: typeof inType; getTypeAnnotation: typeof getTypeAnnotation; isBaseType: typeof isBaseType; couldBeBaseType: typeof couldBeBaseType; baseTypeStrictlyMatches: typeof baseTypeStrictlyMatches; isGenericType: typeof isGenericType; replaceWithMultiple: typeof replaceWithMultiple; replaceWithSourceString: typeof replaceWithSourceString; replaceWith: typeof replaceWith; replaceExpressionWithStatements: typeof replaceExpressionWithStatements; replaceInline: typeof replaceInline; evaluateTruthy: typeof evaluateTruthy; evaluate: typeof evaluate; ensureBlock: typeof ensureBlock; unwrapFunctionEnvironment: typeof unwrapFunctionEnvironment; arrowFunctionToExpression: typeof arrowFunctionToExpression; splitExportDeclaration: typeof splitExportDeclaration; ensureFunctionName: typeof ensureFunctionName; matchesPattern: typeof matchesPattern; isStatic: typeof isStatic; isNodeType: typeof isNodeType; canHaveVariableDeclarationOrExpression: typeof canHaveVariableDeclarationOrExpression; canSwapBetweenExpressionAndStatement: typeof canSwapBetweenExpressionAndStatement; isCompletionRecord: typeof isCompletionRecord; isStatementOrBlock: typeof isStatementOrBlock; referencesImport: typeof referencesImport; getSource: typeof getSource; willIMaybeExecuteBefore: typeof willIMaybeExecuteBefore; _guessExecutionStatusRelativeTo: typeof _guessExecutionStatusRelativeTo; resolve: typeof resolve; isConstantExpression: typeof isConstantExpression; isInStrictMode: typeof isInStrictMode; isDenylisted: typeof isDenylisted; skip: typeof skip; skipKey: typeof skipKey; stop: typeof stop; setContext: typeof setContext; requeue: typeof requeue; requeueComputedKeyAndDecorators: typeof requeueComputedKeyAndDecorators; remove: typeof remove; insertBefore: typeof insertBefore; insertAfter: typeof insertAfter; unshiftContainer: typeof unshiftContainer; pushContainer: typeof pushContainer; getOpposite: typeof getOpposite; getCompletionRecords: typeof getCompletionRecords; getSibling: typeof getSibling; getPrevSibling: typeof getPrevSibling; getNextSibling: typeof getNextSibling; getAllNextSiblings: typeof getAllNextSiblings; getAllPrevSiblings: typeof getAllPrevSiblings; get: typeof get; getAssignmentIdentifiers: typeof getAssignmentIdentifiers; getBindingIdentifiers: typeof getBindingIdentifiers; getOuterBindingIdentifiers: typeof getOuterBindingIdentifiers; getBindingIdentifierPaths: typeof getBindingIdentifierPaths; getOuterBindingIdentifierPaths: typeof getOuterBindingIdentifierPaths; shareCommentsWithSiblings: typeof shareCommentsWithSiblings; addComment: typeof addComment; addComments: typeof addComments; }; interface NodePathOverwrites { /** * NOTE: This assertion doesn't narrow the type on unions of * NodePaths, due to https://github.com/microsoft/TypeScript/issues/44212 * * @see ./conversion.ts for implementation. */ ensureBlock(this: NodePath_Final): asserts this is NodePath_Final<(t.Loop | t.WithStatement | t.Function | t.LabeledStatement | t.CatchClause) & { body: t.BlockStatement; }>; /** * @see ./introspection.ts for implementation. */ isStatementOrBlock(this: NodePath_Final): this is NodePath_Final; } type NodePathMixins = Omit; interface NodePath["type"], P extends t.Node = T extends null ? t.Node : NonNullable]>> extends InstanceType, NodePathAssertions, NodePathValidators, NodePathMixins, NodePathOverwrites { type: T; node: N; parent: P; parentPath: NodePath_Final

; } declare const NodePath_Final: { new (hub: HubInterface | undefined, parent: t.Node): { parent: t.Node; hub: HubInterface; data: Record | null; context: TraversalContext; scope: Scope; contexts: TraversalContext[]; state: any; opts: TraverseOptions & ExplodedVisitor; _traverseFlags: number; get removed(): boolean; set removed(arg: boolean); get shouldStop(): boolean; set shouldStop(arg: boolean); get shouldSkip(): boolean; set shouldSkip(arg: boolean); skipKeys: Record | null; parentPath: NodePath_Final | null; container: t.Node | t.Node[] | null; listKey: string | null | undefined; key: string | number | null; node: t.Node | null; type: t.Node["type"] | null; _store: Map | null; getScope(this: NodePath_Final, scope: Scope): Scope; setData(key: string | symbol, val: T): T; getData(key: string | symbol, def?: any): any; hasNode(): boolean; buildCodeFrameError(msg: string, Error?: new () => Error): Error; traverse(this: NodePath_Final, visitor: { [P in keyof T]: VisitorProp; }, state: S): void; traverse(this: NodePath_Final, visitor: { [P in keyof T]: VisitorProp; }): void; traverse(this: NodePath_Final, visitor: TraverseOptions & Visitor, state: S): void; traverse(this: NodePath_Final, visitor: TraverseOptions & Visitor): void; set(key: string, node: any): void; getPathLocation(this: NodePath_Final): string; debug(this: NodePath_Final, message: string): void; toString(): string; get inList(): boolean; set inList(inList: boolean); get parentKey(): string; }; get({ hub, parentPath, parent, container, listKey, key, }: { hub?: HubInterface; parentPath: NodePath_Final | null | undefined; parent: t.Node; container: t.Node | t.Node[]; listKey?: string | null; key: string | number; }): NodePath_Final; }; type NodePath_Final = T extends any ? NodePath : never; declare let pathsCache: WeakMap>; declare let scope: WeakMap; declare function clear(): void; declare function clearPath(): void; declare function clearScope(): void; declare function getCachedPaths(path: NodePath_Final): Map> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath | NodePath | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath | NodePath> | NodePath | NodePath> | NodePath> | NodePath> | NodePath> | NodePath> | NodePath>> | null | undefined; declare function getOrCreateCachedPaths(node: Node, parentPath?: NodePath_Final | null): Map; declare const __cache_ts_clear: typeof clear; declare const __cache_ts_clearPath: typeof clearPath; declare const __cache_ts_clearScope: typeof clearScope; declare const __cache_ts_getCachedPaths: typeof getCachedPaths; declare const __cache_ts_getOrCreateCachedPaths: typeof getOrCreateCachedPaths; declare const __cache_ts_scope: typeof scope; declare namespace __cache_ts { export { __cache_ts_clear as clear, __cache_ts_clearPath as clearPath, __cache_ts_clearScope as clearScope, __cache_ts_getCachedPaths as getCachedPaths, __cache_ts_getOrCreateCachedPaths as getOrCreateCachedPaths, pathsCache as path, __cache_ts_scope as scope }; } type VisitWrapper = (stateName: string | undefined, visitorType: VisitPhase, callback: VisitNodeFunction) => VisitNodeFunction; declare function isExplodedVisitor(visitor: Visitor): visitor is ExplodedVisitor; /** * explode() will take a visitor object with all of the various shorthands * that we support, and validates & normalizes it into a common format, ready * to be used in traversal * * The various shorthands are: * * `Identifier() { ... }` -> `Identifier: { enter() { ... } }` * * `"Identifier|NumericLiteral": { ... }` -> `Identifier: { ... }, NumericLiteral: { ... }` * * Aliases in `@babel/types`: e.g. `Property: { ... }` -> `ObjectProperty: { ... }, ClassProperty: { ... }` * Other normalizations are: * * Visitors of virtual types are wrapped, so that they are only visited when * their dynamic check passes * * `enter` and `exit` functions are wrapped in arrays, to ease merging of * visitors */ declare function explode$1(visitor: { [P in keyof T]: VisitorProp; }): ExplodedVisitor; declare function explode$1(visitor: Visitor): ExplodedVisitor; declare function verify$1(visitor: Visitor): void; declare function merge(visitors: Visitor[]): ExplodedVisitor; declare function merge(visitors: Visitor[], states?: State[], wrapper?: VisitWrapper | null): ExplodedVisitor; declare function environmentVisitor(visitor: Visitor): ExplodedVisitor; type __visitors_ts_VisitWrapper = VisitWrapper; declare const __visitors_ts_environmentVisitor: typeof environmentVisitor; declare const __visitors_ts_isExplodedVisitor: typeof isExplodedVisitor; declare const __visitors_ts_merge: typeof merge; declare namespace __visitors_ts { export { type __visitors_ts_VisitWrapper as VisitWrapper, __visitors_ts_environmentVisitor as environmentVisitor, explode$1 as explode, __visitors_ts_isExplodedVisitor as isExplodedVisitor, __visitors_ts_merge as merge, verify$1 as verify }; } declare function traverse(parent: t.Node, opts: { [P in keyof T]: VisitorProp; }, scope: Scope | null | undefined, state: S, parentPath?: NodePath_Final, visitSelf?: boolean): void; declare function traverse(parent: t.Node, opts: { [P in keyof T]: VisitorProp; }, scope?: Scope | null, state?: any, parentPath?: NodePath_Final, visitSelf?: boolean): void; declare function traverse(parent: t.Node, opts: TraverseOptions & Visitor, scope: Scope | null | undefined, state: S, parentPath?: NodePath_Final, visitSelf?: boolean): void; declare function traverse(parent: t.Node, opts: TraverseOptions & Visitor, scope?: Scope | null, state?: any, parentPath?: NodePath_Final, visitSelf?: boolean): void; declare namespace traverse { var visitors: typeof __visitors_ts; var verify: typeof verify$1; var explode: typeof explode$1; var cheap: (node: t.Node, enter: (node: t.Node) => void) => void; var node: (node: t.Node, opts: TraverseOptions & ExplodedVisitor, scope?: Scope, state?: any, path?: NodePath_Final, skipKeys?: Record) => void; var clearNode: (node: t.Node, opts?: RemovePropertiesOptions) => void; var removeProperties: (tree: t.Node, opts?: RemovePropertiesOptions) => t.Node; var hasType: (tree: t.Node, type: t.Node["type"], denylistTypes?: string[]) => boolean; var cache: typeof __cache_ts; } //# sourceMappingURL=index.d.ts.map export { Binding, type BindingKind, type ExplodedVisitor, Hub, type HubInterface, NodePath_Final as NodePath, Scope, type TraverseOptions, type VisitWrapper, type Visitor, type VisitorBase, traverse as default, __visitors_ts as visitors };