@sitecore/sc-contenthub-blok 1.0.14 → 1.0.27

package/node_modules/@babel/types/lib/index.d.ts

@@ -330,13 +330,13 @@ declare const _default$4: {
  * Takes an array of `types` and flattens them, removing duplicates and
  * returns a `UnionTypeAnnotation` node containing them.
  */
-declare function createFlowUnionType<T extends FlowType>(types: [T] | Array<T>): T | UnionTypeAnnotation;
+declare function createFlowUnionType<T extends FlowType>(types: [T] | T[]): T | UnionTypeAnnotation;
 
 /**
  * Takes an array of `types` and flattens them, removing duplicates and
  * returns a `UnionTypeAnnotation` node containing them.
  */
-declare function createTSUnionType(typeAnnotations: Array<TSTypeAnnotation | TSType>): TSType;
+declare function createTSUnionType(typeAnnotations: (TSTypeAnnotation | TSType)[]): TSType;
 
 interface BaseComment {
     value: string;
@@ -365,7 +365,6 @@ interface SourceLocation {
     identifierName: string | undefined | null;
 }
 interface BaseNode {
-    type: Node["type"];
     leadingComments?: Comment[] | null;
     innerComments?: Comment[] | null;
     trailingComments?: Comment[] | null;
@@ -379,7 +378,7 @@ type CommentTypeShorthand = "leading" | "inner" | "trailing";
 type Node = AnyTypeAnnotation | ArgumentPlaceholder | ArrayExpression | ArrayPattern | ArrayTypeAnnotation | ArrowFunctionExpression | AssignmentExpression | AssignmentPattern | AwaitExpression | BigIntLiteral | BinaryExpression | BindExpression | BlockStatement | BooleanLiteral | BooleanLiteralTypeAnnotation | BooleanTypeAnnotation | BreakStatement | CallExpression | CatchClause | ClassAccessorProperty | ClassBody | ClassDeclaration | ClassExpression | ClassImplements | ClassMethod | ClassPrivateMethod | ClassPrivateProperty | ClassProperty | ConditionalExpression | ContinueStatement | DebuggerStatement | DecimalLiteral | DeclareClass | DeclareExportAllDeclaration | DeclareExportDeclaration | DeclareFunction | DeclareInterface | DeclareModule | DeclareModuleExports | DeclareOpaqueType | DeclareTypeAlias | DeclareVariable | DeclaredPredicate | Decorator | Directive | DirectiveLiteral | DoExpression | DoWhileStatement | EmptyStatement | EmptyTypeAnnotation | EnumBooleanBody | EnumBooleanMember | EnumDeclaration | EnumDefaultedMember | EnumNumberBody | EnumNumberMember | EnumStringBody | EnumStringMember | EnumSymbolBody | ExistsTypeAnnotation | ExportAllDeclaration | ExportDefaultDeclaration | ExportDefaultSpecifier | ExportNamedDeclaration | ExportNamespaceSpecifier | ExportSpecifier | ExpressionStatement | File | ForInStatement | ForOfStatement | ForStatement | FunctionDeclaration | FunctionExpression | FunctionTypeAnnotation | FunctionTypeParam | GenericTypeAnnotation | Identifier | IfStatement | Import | ImportAttribute | ImportDeclaration | ImportDefaultSpecifier | ImportExpression | ImportNamespaceSpecifier | ImportSpecifier | IndexedAccessType | InferredPredicate | InterfaceDeclaration | InterfaceExtends | InterfaceTypeAnnotation | InterpreterDirective | IntersectionTypeAnnotation | JSXAttribute | JSXClosingElement | JSXClosingFragment | JSXElement | JSXEmptyExpression | JSXExpressionContainer | JSXFragment | JSXIdentifier | JSXMemberExpression | JSXNamespacedName | JSXOpeningElement | JSXOpeningFragment | JSXSpreadAttribute | JSXSpreadChild | JSXText | LabeledStatement | LogicalExpression | MemberExpression | MetaProperty | MixedTypeAnnotation | ModuleExpression | NewExpression | Noop | NullLiteral | NullLiteralTypeAnnotation | NullableTypeAnnotation | NumberLiteral$1 | NumberLiteralTypeAnnotation | NumberTypeAnnotation | NumericLiteral | ObjectExpression | ObjectMethod | ObjectPattern | ObjectProperty | ObjectTypeAnnotation | ObjectTypeCallProperty | ObjectTypeIndexer | ObjectTypeInternalSlot | ObjectTypeProperty | ObjectTypeSpreadProperty | OpaqueType | OptionalCallExpression | OptionalIndexedAccessType | OptionalMemberExpression | ParenthesizedExpression | PipelineBareFunction | PipelinePrimaryTopicReference | PipelineTopicExpression | Placeholder | PrivateName | Program | QualifiedTypeIdentifier | RecordExpression | RegExpLiteral | RegexLiteral$1 | RestElement | RestProperty$1 | ReturnStatement | SequenceExpression | SpreadElement | SpreadProperty$1 | StaticBlock | StringLiteral | StringLiteralTypeAnnotation | StringTypeAnnotation | Super | SwitchCase | SwitchStatement | SymbolTypeAnnotation | TSAnyKeyword | TSArrayType | TSAsExpression | TSBigIntKeyword | TSBooleanKeyword | TSCallSignatureDeclaration | TSConditionalType | TSConstructSignatureDeclaration | TSConstructorType | TSDeclareFunction | TSDeclareMethod | TSEnumBody | TSEnumDeclaration | TSEnumMember | TSExportAssignment | TSExpressionWithTypeArguments | TSExternalModuleReference | TSFunctionType | TSImportEqualsDeclaration | TSImportType | TSIndexSignature | TSIndexedAccessType | TSInferType | TSInstantiationExpression | TSInterfaceBody | TSInterfaceDeclaration | TSIntersectionType | TSIntrinsicKeyword | TSLiteralType | TSMappedType | TSMethodSignature | TSModuleBlock | TSModuleDeclaration | TSNamedTupleMember | TSNamespaceExportDeclaration | TSNeverKeyword | TSNonNullExpression | TSNullKeyword | TSNumberKeyword | TSObjectKeyword | TSOptionalType | TSParameterProperty | TSParenthesizedType | TSPropertySignature | TSQualifiedName | TSRestType | TSSatisfiesExpression | TSStringKeyword | TSSymbolKeyword | TSTemplateLiteralType | TSThisType | TSTupleType | TSTypeAliasDeclaration | TSTypeAnnotation | TSTypeAssertion | TSTypeLiteral | TSTypeOperator | TSTypeParameter | TSTypeParameterDeclaration | TSTypeParameterInstantiation | TSTypePredicate | TSTypeQuery | TSTypeReference | TSUndefinedKeyword | TSUnionType | TSUnknownKeyword | TSVoidKeyword | TaggedTemplateExpression | TemplateElement | TemplateLiteral | ThisExpression | ThisTypeAnnotation | ThrowStatement | TopicReference | TryStatement | TupleExpression | TupleTypeAnnotation | TypeAlias | TypeAnnotation | TypeCastExpression | TypeParameter | TypeParameterDeclaration | TypeParameterInstantiation | TypeofTypeAnnotation | UnaryExpression | UnionTypeAnnotation | UpdateExpression | V8IntrinsicIdentifier | VariableDeclaration | VariableDeclarator | Variance | VoidPattern | VoidTypeAnnotation | WhileStatement | WithStatement | YieldExpression;
 interface ArrayExpression extends BaseNode {
     type: "ArrayExpression";
-    elements: Array<null | Expression | SpreadElement>;
+    elements: (null | Expression | SpreadElement)[];
 }
 interface AssignmentExpression extends BaseNode {
     type: "AssignmentExpression";
@@ -407,8 +406,8 @@ interface DirectiveLiteral extends BaseNode {
 }
 interface BlockStatement extends BaseNode {
     type: "BlockStatement";
-    body: Array<Statement>;
-    directives: Array<Directive>;
+    body: Statement[];
+    directives: Directive[];
 }
 interface BreakStatement extends BaseNode {
     type: "BreakStatement";
@@ -417,7 +416,7 @@ interface BreakStatement extends BaseNode {
 interface CallExpression extends BaseNode {
     type: "CallExpression";
     callee: Expression | Super | V8IntrinsicIdentifier;
-    arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+    arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
     optional?: boolean | null;
     typeArguments?: TypeParameterInstantiation | null;
     typeParameters?: TSTypeParameterInstantiation | null;
@@ -455,8 +454,8 @@ interface ExpressionStatement extends BaseNode {
 interface File extends BaseNode {
     type: "File";
     program: Program;
-    comments?: Array<CommentBlock | CommentLine> | null;
-    tokens?: Array<any> | null;
+    comments?: (CommentBlock | CommentLine)[] | null;
+    tokens?: any[] | null;
 }
 interface ForInStatement extends BaseNode {
     type: "ForInStatement";
@@ -474,7 +473,7 @@ interface ForStatement extends BaseNode {
 interface FunctionDeclaration extends BaseNode {
     type: "FunctionDeclaration";
     id?: Identifier | null;
-    params: Array<FunctionParameter>;
+    params: FunctionParameter[];
     body: BlockStatement;
     generator: boolean;
     async: boolean;
@@ -486,7 +485,7 @@ interface FunctionDeclaration extends BaseNode {
 interface FunctionExpression extends BaseNode {
     type: "FunctionExpression";
     id?: Identifier | null;
-    params: Array<FunctionParameter>;
+    params: FunctionParameter[];
     body: BlockStatement;
     generator: boolean;
     async: boolean;
@@ -497,7 +496,7 @@ interface FunctionExpression extends BaseNode {
 interface Identifier extends BaseNode {
     type: "Identifier";
     name: string;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -563,32 +562,32 @@ interface MemberExpression extends BaseNode {
 interface NewExpression extends BaseNode {
     type: "NewExpression";
     callee: Expression | Super | V8IntrinsicIdentifier;
-    arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+    arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
     optional?: boolean | null;
     typeArguments?: TypeParameterInstantiation | null;
     typeParameters?: TSTypeParameterInstantiation | null;
 }
 interface Program extends BaseNode {
     type: "Program";
-    body: Array<Statement>;
-    directives: Array<Directive>;
+    body: Statement[];
+    directives: Directive[];
     sourceType: "script" | "module";
     interpreter?: InterpreterDirective | null;
 }
 interface ObjectExpression extends BaseNode {
     type: "ObjectExpression";
-    properties: Array<ObjectMethod | ObjectProperty | SpreadElement>;
+    properties: (ObjectMethod | ObjectProperty | SpreadElement)[];
 }
 interface ObjectMethod extends BaseNode {
     type: "ObjectMethod";
     kind: "method" | "get" | "set";
     key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral;
-    params: Array<FunctionParameter>;
+    params: FunctionParameter[];
     body: BlockStatement;
     computed: boolean;
     generator: boolean;
     async: boolean;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
     typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
 }
@@ -598,12 +597,12 @@ interface ObjectProperty extends BaseNode {
     value: Expression | PatternLike;
     computed: boolean;
     shorthand: boolean;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
 }
 interface RestElement extends BaseNode {
     type: "RestElement";
     argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -613,7 +612,7 @@ interface RestElement extends BaseNode {
 interface RestProperty$1 extends BaseNode {
     type: "RestProperty";
     argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -623,7 +622,7 @@ interface ReturnStatement extends BaseNode {
 }
 interface SequenceExpression extends BaseNode {
     type: "SequenceExpression";
-    expressions: Array<Expression>;
+    expressions: Expression[];
 }
 interface ParenthesizedExpression extends BaseNode {
     type: "ParenthesizedExpression";
@@ -632,12 +631,12 @@ interface ParenthesizedExpression extends BaseNode {
 interface SwitchCase extends BaseNode {
     type: "SwitchCase";
     test?: Expression | null;
-    consequent: Array<Statement>;
+    consequent: Statement[];
 }
 interface SwitchStatement extends BaseNode {
     type: "SwitchStatement";
     discriminant: Expression;
-    cases: Array<SwitchCase>;
+    cases: SwitchCase[];
 }
 interface ThisExpression extends BaseNode {
     type: "ThisExpression";
@@ -667,7 +666,7 @@ interface UpdateExpression extends BaseNode {
 interface VariableDeclaration extends BaseNode {
     type: "VariableDeclaration";
     kind: "var" | "let" | "const" | "using" | "await using";
-    declarations: Array<VariableDeclarator>;
+    declarations: VariableDeclarator[];
     declare?: boolean | null;
 }
 interface VariableDeclarator extends BaseNode {
@@ -690,20 +689,20 @@ interface AssignmentPattern extends BaseNode {
     type: "AssignmentPattern";
     left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression;
     right: Expression;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
 interface ArrayPattern extends BaseNode {
     type: "ArrayPattern";
-    elements: Array<null | PatternLike>;
-    decorators?: Array<Decorator> | null;
+    elements: (null | PatternLike)[];
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
 interface ArrowFunctionExpression extends BaseNode {
     type: "ArrowFunctionExpression";
-    params: Array<FunctionParameter>;
+    params: FunctionParameter[];
     body: BlockStatement | Expression;
     async: boolean;
     expression: boolean;
@@ -714,15 +713,15 @@ interface ArrowFunctionExpression extends BaseNode {
 }
 interface ClassBody extends BaseNode {
     type: "ClassBody";
-    body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>;
+    body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[];
 }
 interface ClassExpression extends BaseNode {
     type: "ClassExpression";
     id?: Identifier | null;
     superClass?: Expression | null;
     body: ClassBody;
-    decorators?: Array<Decorator> | null;
-    implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
+    decorators?: Decorator[] | null;
+    implements?: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
     mixins?: InterfaceExtends | null;
     superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
     typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -732,10 +731,10 @@ interface ClassDeclaration extends BaseNode {
     id?: Identifier | null;
     superClass?: Expression | null;
     body: ClassBody;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     abstract?: boolean | null;
     declare?: boolean | null;
-    implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
+    implements?: (TSExpressionWithTypeArguments | ClassImplements)[] | null;
     mixins?: InterfaceExtends | null;
     superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
     typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
@@ -743,9 +742,9 @@ interface ClassDeclaration extends BaseNode {
 interface ExportAllDeclaration extends BaseNode {
     type: "ExportAllDeclaration";
     source: StringLiteral;
+    attributes?: ImportAttribute[] | null;
     /** @deprecated */
-    assertions?: Array<ImportAttribute> | null;
-    attributes?: Array<ImportAttribute> | null;
+    assertions?: ImportAttribute[] | null;
     exportKind?: "type" | "value" | null;
 }
 interface ExportDefaultDeclaration extends BaseNode {
@@ -756,11 +755,11 @@ interface ExportDefaultDeclaration extends BaseNode {
 interface ExportNamedDeclaration extends BaseNode {
     type: "ExportNamedDeclaration";
     declaration?: Declaration | null;
-    specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>;
+    specifiers: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[];
     source?: StringLiteral | null;
+    attributes?: ImportAttribute[] | null;
     /** @deprecated */
-    assertions?: Array<ImportAttribute> | null;
-    attributes?: Array<ImportAttribute> | null;
+    assertions?: ImportAttribute[] | null;
     exportKind?: "type" | "value" | null;
 }
 interface ExportSpecifier extends BaseNode {
@@ -778,11 +777,11 @@ interface ForOfStatement extends BaseNode {
 }
 interface ImportDeclaration extends BaseNode {
     type: "ImportDeclaration";
-    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+    specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[];
     source: StringLiteral;
+    attributes?: ImportAttribute[] | null;
     /** @deprecated */
-    assertions?: Array<ImportAttribute> | null;
-    attributes?: Array<ImportAttribute> | null;
+    assertions?: ImportAttribute[] | null;
     importKind?: "type" | "typeof" | "value" | null;
     module?: boolean | null;
     phase?: "source" | "defer" | null;
@@ -816,7 +815,7 @@ interface ClassMethod extends BaseNode {
     type: "ClassMethod";
     kind: "get" | "set" | "method" | "constructor";
     key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
-    params: Array<FunctionParameter | TSParameterProperty>;
+    params: (FunctionParameter | TSParameterProperty)[];
     body: BlockStatement;
     computed: boolean;
     static: boolean;
@@ -825,7 +824,7 @@ interface ClassMethod extends BaseNode {
     abstract?: boolean | null;
     access?: "public" | "private" | "protected" | null;
     accessibility?: "public" | "private" | "protected" | null;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     override?: boolean;
     returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
@@ -833,8 +832,8 @@ interface ClassMethod extends BaseNode {
 }
 interface ObjectPattern extends BaseNode {
     type: "ObjectPattern";
-    properties: Array<RestElement | ObjectProperty>;
-    decorators?: Array<Decorator> | null;
+    properties: (RestElement | ObjectProperty)[];
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -868,8 +867,8 @@ interface TemplateElement extends BaseNode {
 }
 interface TemplateLiteral extends BaseNode {
     type: "TemplateLiteral";
-    quasis: Array<TemplateElement>;
-    expressions: Array<Expression | TSType>;
+    quasis: TemplateElement[];
+    expressions: (Expression | TSType)[];
 }
 interface YieldExpression extends BaseNode {
     type: "YieldExpression";
@@ -901,7 +900,7 @@ interface OptionalMemberExpression extends BaseNode {
 interface OptionalCallExpression extends BaseNode {
     type: "OptionalCallExpression";
     callee: Expression;
-    arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>;
+    arguments: (Expression | SpreadElement | ArgumentPlaceholder)[];
     optional: boolean;
     typeArguments?: TypeParameterInstantiation | null;
     typeParameters?: TSTypeParameterInstantiation | null;
@@ -911,7 +910,7 @@ interface ClassProperty extends BaseNode {
     key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
     value?: Expression | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     computed: boolean;
     static: boolean;
     abstract?: boolean | null;
@@ -928,7 +927,7 @@ interface ClassAccessorProperty extends BaseNode {
     key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName;
     value?: Expression | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     computed: boolean;
     static: boolean;
     abstract?: boolean | null;
@@ -944,7 +943,7 @@ interface ClassPrivateProperty extends BaseNode {
     type: "ClassPrivateProperty";
     key: PrivateName;
     value?: Expression | null;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     static: boolean;
     definite?: boolean | null;
     optional?: boolean | null;
@@ -956,7 +955,7 @@ interface ClassPrivateMethod extends BaseNode {
     type: "ClassPrivateMethod";
     kind: "get" | "set" | "method";
     key: PrivateName;
-    params: Array<FunctionParameter | TSParameterProperty>;
+    params: (FunctionParameter | TSParameterProperty)[];
     body: BlockStatement;
     static: boolean;
     abstract?: boolean | null;
@@ -964,7 +963,7 @@ interface ClassPrivateMethod extends BaseNode {
     accessibility?: "public" | "private" | "protected" | null;
     async?: boolean;
     computed?: boolean;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     generator?: boolean;
     optional?: boolean | null;
     override?: boolean;
@@ -977,7 +976,7 @@ interface PrivateName extends BaseNode {
 }
 interface StaticBlock extends BaseNode {
     type: "StaticBlock";
-    body: Array<Statement>;
+    body: Statement[];
 }
 interface ImportAttribute extends BaseNode {
     type: "ImportAttribute";
@@ -1010,10 +1009,10 @@ interface DeclareClass extends BaseNode {
     type: "DeclareClass";
     id: Identifier;
     typeParameters?: TypeParameterDeclaration | null;
-    extends?: Array<InterfaceExtends> | null;
+    extends?: InterfaceExtends[] | null;
     body: ObjectTypeAnnotation;
-    implements?: Array<ClassImplements> | null;
-    mixins?: Array<InterfaceExtends> | null;
+    implements?: ClassImplements[] | null;
+    mixins?: InterfaceExtends[] | null;
 }
 interface DeclareFunction extends BaseNode {
     type: "DeclareFunction";
@@ -1024,7 +1023,7 @@ interface DeclareInterface extends BaseNode {
     type: "DeclareInterface";
     id: Identifier;
     typeParameters?: TypeParameterDeclaration | null;
-    extends?: Array<InterfaceExtends> | null;
+    extends?: InterfaceExtends[] | null;
     body: ObjectTypeAnnotation;
 }
 interface DeclareModule extends BaseNode {
@@ -1057,19 +1056,19 @@ interface DeclareVariable extends BaseNode {
 interface DeclareExportDeclaration extends BaseNode {
     type: "DeclareExportDeclaration";
     declaration?: Flow | null;
-    specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null;
+    specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null;
     source?: StringLiteral | null;
-    attributes?: Array<ImportAttribute> | null;
+    attributes?: ImportAttribute[] | null;
     /** @deprecated */
-    assertions?: Array<ImportAttribute> | null;
+    assertions?: ImportAttribute[] | null;
     default?: boolean | null;
 }
 interface DeclareExportAllDeclaration extends BaseNode {
     type: "DeclareExportAllDeclaration";
     source: StringLiteral;
-    attributes?: Array<ImportAttribute> | null;
+    attributes?: ImportAttribute[] | null;
     /** @deprecated */
-    assertions?: Array<ImportAttribute> | null;
+    assertions?: ImportAttribute[] | null;
     exportKind?: "type" | "value" | null;
 }
 interface DeclaredPredicate extends BaseNode {
@@ -1082,7 +1081,7 @@ interface ExistsTypeAnnotation extends BaseNode {
 interface FunctionTypeAnnotation extends BaseNode {
     type: "FunctionTypeAnnotation";
     typeParameters?: TypeParameterDeclaration | null;
-    params: Array<FunctionTypeParam>;
+    params: FunctionTypeParam[];
     rest?: FunctionTypeParam | null;
     returnType: FlowType;
     this?: FunctionTypeParam | null;
@@ -1110,17 +1109,17 @@ interface InterfaceDeclaration extends BaseNode {
     type: "InterfaceDeclaration";
     id: Identifier;
     typeParameters?: TypeParameterDeclaration | null;
-    extends?: Array<InterfaceExtends> | null;
+    extends?: InterfaceExtends[] | null;
     body: ObjectTypeAnnotation;
 }
 interface InterfaceTypeAnnotation extends BaseNode {
     type: "InterfaceTypeAnnotation";
-    extends?: Array<InterfaceExtends> | null;
+    extends?: InterfaceExtends[] | null;
     body: ObjectTypeAnnotation;
 }
 interface IntersectionTypeAnnotation extends BaseNode {
     type: "IntersectionTypeAnnotation";
-    types: Array<FlowType>;
+    types: FlowType[];
 }
 interface MixedTypeAnnotation extends BaseNode {
     type: "MixedTypeAnnotation";
@@ -1141,10 +1140,10 @@ interface NumberTypeAnnotation extends BaseNode {
 }
 interface ObjectTypeAnnotation extends BaseNode {
     type: "ObjectTypeAnnotation";
-    properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>;
-    indexers?: Array<ObjectTypeIndexer>;
-    callProperties?: Array<ObjectTypeCallProperty>;
-    internalSlots?: Array<ObjectTypeInternalSlot>;
+    properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[];
+    indexers?: ObjectTypeIndexer[];
+    callProperties?: ObjectTypeCallProperty[];
+    internalSlots?: ObjectTypeInternalSlot[];
     exact: boolean;
     inexact?: boolean | null;
 }
@@ -1211,7 +1210,7 @@ interface ThisTypeAnnotation extends BaseNode {
 }
 interface TupleTypeAnnotation extends BaseNode {
     type: "TupleTypeAnnotation";
-    types: Array<FlowType>;
+    types: FlowType[];
 }
 interface TypeofTypeAnnotation extends BaseNode {
     type: "TypeofTypeAnnotation";
@@ -1241,15 +1240,15 @@ interface TypeParameter extends BaseNode {
 }
 interface TypeParameterDeclaration extends BaseNode {
     type: "TypeParameterDeclaration";
-    params: Array<TypeParameter>;
+    params: TypeParameter[];
 }
 interface TypeParameterInstantiation extends BaseNode {
     type: "TypeParameterInstantiation";
-    params: Array<FlowType>;
+    params: FlowType[];
 }
 interface UnionTypeAnnotation extends BaseNode {
     type: "UnionTypeAnnotation";
-    types: Array<FlowType>;
+    types: FlowType[];
 }
 interface Variance extends BaseNode {
     type: "Variance";
@@ -1265,25 +1264,25 @@ interface EnumDeclaration extends BaseNode {
 }
 interface EnumBooleanBody extends BaseNode {
     type: "EnumBooleanBody";
-    members: Array<EnumBooleanMember>;
+    members: EnumBooleanMember[];
     explicitType: boolean;
     hasUnknownMembers: boolean;
 }
 interface EnumNumberBody extends BaseNode {
     type: "EnumNumberBody";
-    members: Array<EnumNumberMember>;
+    members: EnumNumberMember[];
     explicitType: boolean;
     hasUnknownMembers: boolean;
 }
 interface EnumStringBody extends BaseNode {
     type: "EnumStringBody";
-    members: Array<EnumStringMember | EnumDefaultedMember>;
+    members: (EnumStringMember | EnumDefaultedMember)[];
     explicitType: boolean;
     hasUnknownMembers: boolean;
 }
 interface EnumSymbolBody extends BaseNode {
     type: "EnumSymbolBody";
-    members: Array<EnumDefaultedMember>;
+    members: EnumDefaultedMember[];
     hasUnknownMembers: boolean;
 }
 interface EnumBooleanMember extends BaseNode {
@@ -1329,7 +1328,7 @@ interface JSXElement extends BaseNode {
     type: "JSXElement";
     openingElement: JSXOpeningElement;
     closingElement?: JSXClosingElement | null;
-    children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+    children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
     selfClosing?: boolean | null;
 }
 interface JSXEmptyExpression extends BaseNode {
@@ -1360,7 +1359,7 @@ interface JSXNamespacedName extends BaseNode {
 interface JSXOpeningElement extends BaseNode {
     type: "JSXOpeningElement";
     name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
-    attributes: Array<JSXAttribute | JSXSpreadAttribute>;
+    attributes: (JSXAttribute | JSXSpreadAttribute)[];
     selfClosing: boolean;
     typeArguments?: TypeParameterInstantiation | null;
     typeParameters?: TSTypeParameterInstantiation | null;
@@ -1377,7 +1376,7 @@ interface JSXFragment extends BaseNode {
     type: "JSXFragment";
     openingFragment: JSXOpeningFragment;
     closingFragment: JSXClosingFragment;
-    children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+    children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[];
 }
 interface JSXOpeningFragment extends BaseNode {
     type: "JSXOpeningFragment";
@@ -1392,7 +1391,7 @@ interface Placeholder extends BaseNode {
     type: "Placeholder";
     expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern";
     name: Identifier;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     optional?: boolean | null;
     typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
 }
@@ -1423,11 +1422,11 @@ interface ExportDefaultSpecifier extends BaseNode {
 }
 interface RecordExpression extends BaseNode {
     type: "RecordExpression";
-    properties: Array<ObjectProperty | SpreadElement>;
+    properties: (ObjectProperty | SpreadElement)[];
 }
 interface TupleExpression extends BaseNode {
     type: "TupleExpression";
-    elements: Array<Expression | SpreadElement>;
+    elements: (Expression | SpreadElement)[];
 }
 interface DecimalLiteral extends BaseNode {
     type: "DecimalLiteral";
@@ -1458,7 +1457,7 @@ interface TSParameterProperty extends BaseNode {
     type: "TSParameterProperty";
     parameter: Identifier | AssignmentPattern;
     accessibility?: "public" | "private" | "protected" | null;
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     override?: boolean | null;
     readonly?: boolean | null;
 }
@@ -1466,7 +1465,7 @@ interface TSDeclareFunction extends BaseNode {
     type: "TSDeclareFunction";
     id?: Identifier | null;
     typeParameters?: TSTypeParameterDeclaration | Noop | null;
-    params: Array<FunctionParameter>;
+    params: FunctionParameter[];
     returnType?: TSTypeAnnotation | Noop | null;
     async?: boolean;
     declare?: boolean | null;
@@ -1474,10 +1473,10 @@ interface TSDeclareFunction extends BaseNode {
 }
 interface TSDeclareMethod extends BaseNode {
     type: "TSDeclareMethod";
-    decorators?: Array<Decorator> | null;
+    decorators?: Decorator[] | null;
     key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression;
     typeParameters?: TSTypeParameterDeclaration | Noop | null;
-    params: Array<FunctionParameter | TSParameterProperty>;
+    params: (FunctionParameter | TSParameterProperty)[];
     returnType?: TSTypeAnnotation | Noop | null;
     abstract?: boolean | null;
     access?: "public" | "private" | "protected" | null;
@@ -1498,13 +1497,13 @@ interface TSQualifiedName extends BaseNode {
 interface TSCallSignatureDeclaration extends BaseNode {
     type: "TSCallSignatureDeclaration";
     typeParameters?: TSTypeParameterDeclaration | null;
-    parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+    parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
     typeAnnotation?: TSTypeAnnotation | null;
 }
 interface TSConstructSignatureDeclaration extends BaseNode {
     type: "TSConstructSignatureDeclaration";
     typeParameters?: TSTypeParameterDeclaration | null;
-    parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+    parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
     typeAnnotation?: TSTypeAnnotation | null;
 }
 interface TSPropertySignature extends BaseNode {
@@ -1520,7 +1519,7 @@ interface TSMethodSignature extends BaseNode {
     type: "TSMethodSignature";
     key: Expression;
     typeParameters?: TSTypeParameterDeclaration | null;
-    parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+    parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
     typeAnnotation?: TSTypeAnnotation | null;
     computed?: boolean;
     kind: "method" | "get" | "set";
@@ -1528,7 +1527,7 @@ interface TSMethodSignature extends BaseNode {
 }
 interface TSIndexSignature extends BaseNode {
     type: "TSIndexSignature";
-    parameters: Array<Identifier>;
+    parameters: Identifier[];
     typeAnnotation?: TSTypeAnnotation | null;
     readonly?: boolean | null;
     static?: boolean | null;
@@ -1578,13 +1577,13 @@ interface TSThisType extends BaseNode {
 interface TSFunctionType extends BaseNode {
     type: "TSFunctionType";
     typeParameters?: TSTypeParameterDeclaration | null;
-    parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+    parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
     typeAnnotation?: TSTypeAnnotation | null;
 }
 interface TSConstructorType extends BaseNode {
     type: "TSConstructorType";
     typeParameters?: TSTypeParameterDeclaration | null;
-    parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>;
+    parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[];
     typeAnnotation?: TSTypeAnnotation | null;
     abstract?: boolean | null;
 }
@@ -1606,7 +1605,7 @@ interface TSTypeQuery extends BaseNode {
 }
 interface TSTypeLiteral extends BaseNode {
     type: "TSTypeLiteral";
-    members: Array<TSTypeElement>;
+    members: TSTypeElement[];
 }
 interface TSArrayType extends BaseNode {
     type: "TSArrayType";
@@ -1614,7 +1613,7 @@ interface TSArrayType extends BaseNode {
 }
 interface TSTupleType extends BaseNode {
     type: "TSTupleType";
-    elementTypes: Array<TSType | TSNamedTupleMember>;
+    elementTypes: (TSType | TSNamedTupleMember)[];
 }
 interface TSOptionalType extends BaseNode {
     type: "TSOptionalType";
@@ -1632,11 +1631,11 @@ interface TSNamedTupleMember extends BaseNode {
 }
 interface TSUnionType extends BaseNode {
     type: "TSUnionType";
-    types: Array<TSType>;
+    types: TSType[];
 }
 interface TSIntersectionType extends BaseNode {
     type: "TSIntersectionType";
-    types: Array<TSType>;
+    types: TSType[];
 }
 interface TSConditionalType extends BaseNode {
     type: "TSConditionalType";
@@ -1673,8 +1672,8 @@ interface TSMappedType extends BaseNode {
 }
 interface TSTemplateLiteralType extends BaseNode {
     type: "TSTemplateLiteralType";
-    quasis: Array<TemplateElement>;
-    types: Array<TSType>;
+    quasis: TemplateElement[];
+    types: TSType[];
 }
 interface TSLiteralType extends BaseNode {
     type: "TSLiteralType";
@@ -1689,13 +1688,13 @@ interface TSInterfaceDeclaration extends BaseNode {
     type: "TSInterfaceDeclaration";
     id: Identifier;
     typeParameters?: TSTypeParameterDeclaration | null;
-    extends?: Array<TSExpressionWithTypeArguments> | null;
+    extends?: TSExpressionWithTypeArguments[] | null;
     body: TSInterfaceBody;
     declare?: boolean | null;
 }
 interface TSInterfaceBody extends BaseNode {
     type: "TSInterfaceBody";
-    body: Array<TSTypeElement>;
+    body: TSTypeElement[];
 }
 interface TSTypeAliasDeclaration extends BaseNode {
     type: "TSTypeAliasDeclaration";
@@ -1726,12 +1725,12 @@ interface TSTypeAssertion extends BaseNode {
 }
 interface TSEnumBody extends BaseNode {
     type: "TSEnumBody";
-    members: Array<TSEnumMember>;
+    members: TSEnumMember[];
 }
 interface TSEnumDeclaration extends BaseNode {
     type: "TSEnumDeclaration";
     id: Identifier;
-    members: Array<TSEnumMember>;
+    members: TSEnumMember[];
     body?: TSEnumBody | null;
     const?: boolean | null;
     declare?: boolean | null;
@@ -1752,7 +1751,7 @@ interface TSModuleDeclaration extends BaseNode {
 }
 interface TSModuleBlock extends BaseNode {
     type: "TSModuleBlock";
-    body: Array<Statement>;
+    body: Statement[];
 }
 interface TSImportType extends BaseNode {
     type: "TSImportType";
@@ -1790,11 +1789,11 @@ interface TSTypeAnnotation extends BaseNode {
 }
 interface TSTypeParameterInstantiation extends BaseNode {
     type: "TSTypeParameterInstantiation";
-    params: Array<TSType>;
+    params: TSType[];
 }
 interface TSTypeParameterDeclaration extends BaseNode {
     type: "TSTypeParameterDeclaration";
-    params: Array<TSTypeParameter>;
+    params: TSTypeParameter[];
 }
 interface TSTypeParameter extends BaseNode {
     type: "TSTypeParameter";
@@ -2174,15 +2173,15 @@ interface ParentMaps {
 
 /** @deprecated */ declare function bigIntLiteral(value: string): BigIntLiteral;
 declare function bigIntLiteral(value: bigint): BigIntLiteral;
-declare function arrayExpression(elements?: Array<null | Expression | SpreadElement>): ArrayExpression;
+declare function arrayExpression(elements?: (null | Expression | SpreadElement)[]): ArrayExpression;
 declare function assignmentExpression(operator: string, left: LVal | OptionalMemberExpression, right: Expression): AssignmentExpression;
 declare function binaryExpression(operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>", left: Expression | PrivateName, right: Expression): BinaryExpression;
 declare function interpreterDirective(value: string): InterpreterDirective;
 declare function directive(value: DirectiveLiteral): Directive;
 declare function directiveLiteral(value: string): DirectiveLiteral;
-declare function blockStatement(body: Array<Statement>, directives?: Array<Directive>): BlockStatement;
+declare function blockStatement(body: Statement[], directives?: Directive[]): BlockStatement;
 declare function breakStatement(label?: Identifier | null): BreakStatement;
-declare function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>): CallExpression;
+declare function callExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): CallExpression;
 declare function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause;
 declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;
 declare function continueStatement(label?: Identifier | null): ContinueStatement;
@@ -2190,11 +2189,11 @@ declare function debuggerStatement(): DebuggerStatement;
 declare function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;
 declare function emptyStatement(): EmptyStatement;
 declare function expressionStatement(expression: Expression): ExpressionStatement;
-declare function file(program: Program, comments?: Array<CommentBlock | CommentLine> | null, tokens?: Array<any> | null): File;
+declare function file(program: Program, comments?: (CommentBlock | CommentLine)[] | null, tokens?: any[] | null): File;
 declare function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;
 declare function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;
-declare function functionDeclaration(id: Identifier | null | undefined, params: Array<FunctionParameter>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
-declare function functionExpression(id: Identifier | null | undefined, params: Array<FunctionParameter>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
+declare function functionDeclaration(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;
+declare function functionExpression(id: Identifier | null | undefined, params: FunctionParameter[], body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;
 declare function identifier(name: string): Identifier;
 declare function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;
 declare function labeledStatement(label: Identifier, body: Statement): LabeledStatement;
@@ -2205,45 +2204,45 @@ declare function booleanLiteral(value: boolean): BooleanLiteral;
 declare function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;
 declare function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;
 declare function memberExpression(object: Expression | Super, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: boolean | null): MemberExpression;
-declare function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>): NewExpression;
-declare function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
-declare function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;
-declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: Array<FunctionParameter>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
-declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;
+declare function newExpression(callee: Expression | Super | V8IntrinsicIdentifier, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[]): NewExpression;
+declare function program(body: Statement[], directives?: Directive[], sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;
+declare function objectExpression(properties: (ObjectMethod | ObjectProperty | SpreadElement)[]): ObjectExpression;
+declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral, params: FunctionParameter[], body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;
+declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral | BigIntLiteral | DecimalLiteral | PrivateName, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Decorator[] | null): ObjectProperty;
 declare function restElement(argument: Identifier | ArrayPattern | ObjectPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression | RestElement | AssignmentPattern): RestElement;
 declare function returnStatement(argument?: Expression | null): ReturnStatement;
-declare function sequenceExpression(expressions: Array<Expression>): SequenceExpression;
+declare function sequenceExpression(expressions: Expression[]): SequenceExpression;
 declare function parenthesizedExpression(expression: Expression): ParenthesizedExpression;
-declare function switchCase(test: Expression | null | undefined, consequent: Array<Statement>): SwitchCase;
-declare function switchStatement(discriminant: Expression, cases: Array<SwitchCase>): SwitchStatement;
+declare function switchCase(test: Expression | null | undefined, consequent: Statement[]): SwitchCase;
+declare function switchStatement(discriminant: Expression, cases: SwitchCase[]): SwitchStatement;
 declare function thisExpression(): ThisExpression;
 declare function throwStatement(argument: Expression): ThrowStatement;
 declare function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;
 declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;
 declare function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;
-declare function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: Array<VariableDeclarator>): VariableDeclaration;
+declare function variableDeclaration(kind: "var" | "let" | "const" | "using" | "await using", declarations: VariableDeclarator[]): VariableDeclaration;
 declare function variableDeclarator(id: LVal | VoidPattern, init?: Expression | null): VariableDeclarator;
 declare function whileStatement(test: Expression, body: Statement): WhileStatement;
 declare function withStatement(object: Expression, body: Statement): WithStatement;
 declare function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression, right: Expression): AssignmentPattern;
-declare function arrayPattern(elements: Array<null | PatternLike>): ArrayPattern;
-declare function arrowFunctionExpression(params: Array<FunctionParameter>, body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
-declare function classBody(body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>): ClassBody;
-declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassExpression;
-declare function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassDeclaration;
-declare function exportAllDeclaration(source: StringLiteral): ExportAllDeclaration;
+declare function arrayPattern(elements: (null | PatternLike)[]): ArrayPattern;
+declare function arrowFunctionExpression(params: FunctionParameter[], body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;
+declare function classBody(body: (ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock)[]): ClassBody;
+declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassExpression;
+declare function classDeclaration(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Decorator[] | null): ClassDeclaration;
+declare function exportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): ExportAllDeclaration;
 declare function exportDefaultDeclaration(declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression): ExportDefaultDeclaration;
-declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>, source?: StringLiteral | null): ExportNamedDeclaration;
+declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: (ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier)[], source?: StringLiteral | null, attributes?: ImportAttribute[] | null): ExportNamedDeclaration;
 declare function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier;
 declare function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;
-declare function importDeclaration(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: StringLiteral): ImportDeclaration;
+declare function importDeclaration(specifiers: (ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier)[], source: StringLiteral, attributes?: ImportAttribute[] | null): ImportDeclaration;
 declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;
 declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;
 declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;
 declare function importExpression(source: Expression, options?: Expression | null): ImportExpression;
 declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty;
-declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: Array<FunctionParameter | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
-declare function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;
+declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;
+declare function objectPattern(properties: (RestElement | ObjectProperty)[]): ObjectPattern;
 declare function spreadElement(argument: Expression): SpreadElement;
 declare function _super(): Super;
 
@@ -2252,20 +2251,20 @@ declare function templateElement(value: {
     raw: string;
     cooked?: string;
 }, tail?: boolean): TemplateElement;
-declare function templateLiteral(quasis: Array<TemplateElement>, expressions: Array<Expression | TSType>): TemplateLiteral;
+declare function templateLiteral(quasis: TemplateElement[], expressions: (Expression | TSType)[]): TemplateLiteral;
 declare function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;
 declare function awaitExpression(argument: Expression): AwaitExpression;
 declare function _import(): Import;
 
 declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;
 declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;
-declare function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;
-declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;
-declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
-declare function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Array<Decorator> | null, _static?: boolean): ClassPrivateProperty;
-declare function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: Array<FunctionParameter | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;
+declare function optionalCallExpression(callee: Expression, _arguments: (Expression | SpreadElement | ArgumentPlaceholder)[], optional: boolean): OptionalCallExpression;
+declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassProperty;
+declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Decorator[] | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;
+declare function classPrivateProperty(key: PrivateName, value?: Expression | null, decorators?: Decorator[] | null, _static?: boolean): ClassPrivateProperty;
+declare function classPrivateMethod(kind: "get" | "set" | "method" | undefined, key: PrivateName, params: (FunctionParameter | TSParameterProperty)[], body: BlockStatement, _static?: boolean): ClassPrivateMethod;
 declare function privateName(id: Identifier): PrivateName;
-declare function staticBlock(body: Array<Statement>): StaticBlock;
+declare function staticBlock(body: Statement[]): StaticBlock;
 declare function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute;
 declare function anyTypeAnnotation(): AnyTypeAnnotation;
 declare function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;
@@ -2273,32 +2272,32 @@ declare function booleanTypeAnnotation(): BooleanTypeAnnotation;
 declare function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;
 declare function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;
 declare function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;
-declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
+declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareClass;
 declare function declareFunction(id: Identifier): DeclareFunction;
-declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
+declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;
 declare function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;
 declare function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;
 declare function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;
 declare function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;
 declare function declareVariable(id: Identifier): DeclareVariable;
-declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null, source?: StringLiteral | null, attributes?: Array<ImportAttribute> | null): DeclareExportDeclaration;
-declare function declareExportAllDeclaration(source: StringLiteral, attributes?: Array<ImportAttribute> | null): DeclareExportAllDeclaration;
+declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: (ExportSpecifier | ExportNamespaceSpecifier)[] | null, source?: StringLiteral | null, attributes?: ImportAttribute[] | null): DeclareExportDeclaration;
+declare function declareExportAllDeclaration(source: StringLiteral, attributes?: ImportAttribute[] | null): DeclareExportAllDeclaration;
 declare function declaredPredicate(value: Flow): DeclaredPredicate;
 declare function existsTypeAnnotation(): ExistsTypeAnnotation;
-declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: Array<FunctionTypeParam>, rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
+declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: FunctionTypeParam[], rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;
 declare function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam;
 declare function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;
 declare function inferredPredicate(): InferredPredicate;
 declare function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;
-declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
-declare function interfaceTypeAnnotation(_extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
-declare function intersectionTypeAnnotation(types: Array<FlowType>): IntersectionTypeAnnotation;
+declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;
+declare function interfaceTypeAnnotation(_extends: InterfaceExtends[] | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;
+declare function intersectionTypeAnnotation(types: FlowType[]): IntersectionTypeAnnotation;
 declare function mixedTypeAnnotation(): MixedTypeAnnotation;
 declare function emptyTypeAnnotation(): EmptyTypeAnnotation;
 declare function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;
 declare function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;
 declare function numberTypeAnnotation(): NumberTypeAnnotation;
-declare function objectTypeAnnotation(properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>, indexers?: Array<ObjectTypeIndexer>, callProperties?: Array<ObjectTypeCallProperty>, internalSlots?: Array<ObjectTypeInternalSlot>, exact?: boolean): ObjectTypeAnnotation;
+declare function objectTypeAnnotation(properties: (ObjectTypeProperty | ObjectTypeSpreadProperty)[], indexers?: ObjectTypeIndexer[], callProperties?: ObjectTypeCallProperty[], internalSlots?: ObjectTypeInternalSlot[], exact?: boolean): ObjectTypeAnnotation;
 declare function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot;
 declare function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty;
 declare function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer;
@@ -2310,22 +2309,22 @@ declare function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAn
 declare function stringTypeAnnotation(): StringTypeAnnotation;
 declare function symbolTypeAnnotation(): SymbolTypeAnnotation;
 declare function thisTypeAnnotation(): ThisTypeAnnotation;
-declare function tupleTypeAnnotation(types: Array<FlowType>): TupleTypeAnnotation;
+declare function tupleTypeAnnotation(types: FlowType[]): TupleTypeAnnotation;
 declare function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;
 declare function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;
 declare function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;
 declare function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;
 declare function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter;
-declare function typeParameterDeclaration(params: Array<TypeParameter>): TypeParameterDeclaration;
-declare function typeParameterInstantiation(params: Array<FlowType>): TypeParameterInstantiation;
-declare function unionTypeAnnotation(types: Array<FlowType>): UnionTypeAnnotation;
+declare function typeParameterDeclaration(params: TypeParameter[]): TypeParameterDeclaration;
+declare function typeParameterInstantiation(params: FlowType[]): TypeParameterInstantiation;
+declare function unionTypeAnnotation(types: FlowType[]): UnionTypeAnnotation;
 declare function variance(kind: "minus" | "plus"): Variance;
 declare function voidTypeAnnotation(): VoidTypeAnnotation;
 declare function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration;
-declare function enumBooleanBody(members: Array<EnumBooleanMember>): EnumBooleanBody;
-declare function enumNumberBody(members: Array<EnumNumberMember>): EnumNumberBody;
-declare function enumStringBody(members: Array<EnumStringMember | EnumDefaultedMember>): EnumStringBody;
-declare function enumSymbolBody(members: Array<EnumDefaultedMember>): EnumSymbolBody;
+declare function enumBooleanBody(members: EnumBooleanMember[]): EnumBooleanBody;
+declare function enumNumberBody(members: EnumNumberMember[]): EnumNumberBody;
+declare function enumStringBody(members: (EnumStringMember | EnumDefaultedMember)[]): EnumStringBody;
+declare function enumSymbolBody(members: EnumDefaultedMember[]): EnumSymbolBody;
 declare function enumBooleanMember(id: Identifier): EnumBooleanMember;
 declare function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember;
 declare function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember;
@@ -2336,7 +2335,7 @@ declare function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: J
 
 declare function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement;
 
-declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>, selfClosing?: boolean | null): JSXElement;
+declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[], selfClosing?: boolean | null): JSXElement;
 
 declare function jsxEmptyExpression(): JSXEmptyExpression;
 
@@ -2350,13 +2349,13 @@ declare function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier
 
 declare function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;
 
-declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: Array<JSXAttribute | JSXSpreadAttribute>, selfClosing?: boolean): JSXOpeningElement;
+declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: (JSXAttribute | JSXSpreadAttribute)[], selfClosing?: boolean): JSXOpeningElement;
 
 declare function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;
 
 declare function jsxText(value: string): JSXText;
 
-declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>): JSXFragment;
+declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: (JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment)[]): JSXFragment;
 
 declare function jsxOpeningFragment(): JSXOpeningFragment;
 
@@ -2370,8 +2369,8 @@ declare function bindExpression(object: Expression, callee: Expression): BindExp
 declare function decorator(expression: Expression): Decorator;
 declare function doExpression(body: BlockStatement, async?: boolean): DoExpression;
 declare function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;
-declare function recordExpression(properties: Array<ObjectProperty | SpreadElement>): RecordExpression;
-declare function tupleExpression(elements?: Array<Expression | SpreadElement>): TupleExpression;
+declare function recordExpression(properties: (ObjectProperty | SpreadElement)[]): RecordExpression;
+declare function tupleExpression(elements?: (Expression | SpreadElement)[]): TupleExpression;
 declare function decimalLiteral(value: string): DecimalLiteral;
 declare function moduleExpression(body: Program): ModuleExpression;
 declare function topicReference(): TopicReference;
@@ -2381,21 +2380,21 @@ declare function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;
 declare function voidPattern(): VoidPattern;
 declare function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;
 
-declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<FunctionParameter>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
+declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: FunctionParameter[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;
 
-declare function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<FunctionParameter | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
+declare function tsDeclareMethod(decorators: Decorator[] | null | undefined, key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: (FunctionParameter | TSParameterProperty)[], returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;
 
 declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;
 
-declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
+declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;
 
-declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
+declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;
 
 declare function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null): TSPropertySignature;
 
-declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
+declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;
 
-declare function tsIndexSignature(parameters: Array<Identifier>, typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
+declare function tsIndexSignature(parameters: Identifier[], typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;
 
 declare function tsAnyKeyword(): TSAnyKeyword;
 
@@ -2425,9 +2424,9 @@ declare function tsVoidKeyword(): TSVoidKeyword;
 
 declare function tsThisType(): TSThisType;
 
-declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
+declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;
 
-declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
+declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: (ArrayPattern | Identifier | ObjectPattern | RestElement)[], typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;
 
 declare function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;
 
@@ -2435,11 +2434,11 @@ declare function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnn
 
 declare function tsTypeQuery(exprName: TSEntityName | TSImportType, typeParameters?: TSTypeParameterInstantiation | null): TSTypeQuery;
 
-declare function tsTypeLiteral(members: Array<TSTypeElement>): TSTypeLiteral;
+declare function tsTypeLiteral(members: TSTypeElement[]): TSTypeLiteral;
 
 declare function tsArrayType(elementType: TSType): TSArrayType;
 
-declare function tsTupleType(elementTypes: Array<TSType | TSNamedTupleMember>): TSTupleType;
+declare function tsTupleType(elementTypes: (TSType | TSNamedTupleMember)[]): TSTupleType;
 
 declare function tsOptionalType(typeAnnotation: TSType): TSOptionalType;
 
@@ -2447,9 +2446,9 @@ declare function tsRestType(typeAnnotation: TSType): TSRestType;
 
 declare function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember;
 
-declare function tsUnionType(types: Array<TSType>): TSUnionType;
+declare function tsUnionType(types: TSType[]): TSUnionType;
 
-declare function tsIntersectionType(types: Array<TSType>): TSIntersectionType;
+declare function tsIntersectionType(types: TSType[]): TSIntersectionType;
 
 declare function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;
 
@@ -2457,21 +2456,21 @@ declare function tsInferType(typeParameter: TSTypeParameter): TSInferType;
 
 declare function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;
 
-declare function tsTypeOperator(typeAnnotation: TSType, operator: string): TSTypeOperator;
+declare function tsTypeOperator(typeAnnotation: TSType, operator?: string): TSTypeOperator;
 
 declare function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;
 
 declare function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType;
 
-declare function tsTemplateLiteralType(quasis: Array<TemplateElement>, types: Array<TSType>): TSTemplateLiteralType;
+declare function tsTemplateLiteralType(quasis: TemplateElement[], types: TSType[]): TSTemplateLiteralType;
 
 declare function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression): TSLiteralType;
 
 declare function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;
 
-declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: Array<TSExpressionWithTypeArguments> | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
+declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: TSExpressionWithTypeArguments[] | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;
 
-declare function tsInterfaceBody(body: Array<TSTypeElement>): TSInterfaceBody;
+declare function tsInterfaceBody(body: TSTypeElement[]): TSInterfaceBody;
 
 declare function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration;
 
@@ -2483,15 +2482,15 @@ declare function tsSatisfiesExpression(expression: Expression, typeAnnotation: T
 
 declare function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;
 
-declare function tsEnumBody(members: Array<TSEnumMember>): TSEnumBody;
+declare function tsEnumBody(members: TSEnumMember[]): TSEnumBody;
 
-declare function tsEnumDeclaration(id: Identifier, members: Array<TSEnumMember>): TSEnumDeclaration;
+declare function tsEnumDeclaration(id: Identifier, members: TSEnumMember[]): TSEnumDeclaration;
 
 declare function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;
 
 declare function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;
 
-declare function tsModuleBlock(body: Array<Statement>): TSModuleBlock;
+declare function tsModuleBlock(body: Statement[]): TSModuleBlock;
 
 declare function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType;
 
@@ -2507,9 +2506,9 @@ declare function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExport
 
 declare function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;
 
-declare function tsTypeParameterInstantiation(params: Array<TSType>): TSTypeParameterInstantiation;
+declare function tsTypeParameterInstantiation(params: TSType[]): TSTypeParameterInstantiation;
 
-declare function tsTypeParameterDeclaration(params: Array<TSTypeParameter>): TSTypeParameterDeclaration;
+declare function tsTypeParameterDeclaration(params: TSTypeParameter[]): TSTypeParameterDeclaration;
 
 declare function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter;
 
@@ -2568,7 +2567,7 @@ declare function addComment<T extends Node>(node: T, type: CommentTypeShorthand,
 /**
  * Add comments of certain type to a node.
  */
-declare function addComments<T extends Node>(node: T, type: CommentTypeShorthand, comments: Array<Comment>): T;
+declare function addComments<T extends Node>(node: T, type: CommentTypeShorthand, comments: Comment[]): T;
 
 declare function inheritInnerComments(child: Node, parent: Node): void;
 
@@ -2714,7 +2713,7 @@ declare const _default$1: {
     (value: number): NumericLiteral | BinaryExpression | UnaryExpression;
     (value: bigint): BigIntLiteral;
     (value: RegExp): RegExpLiteral;
-    (value: ReadonlyArray<unknown>): ArrayExpression;
+    (value: readonly unknown[]): ArrayExpression;
     (value: object): ObjectExpression;
     (value: unknown): Expression;
 };
@@ -2731,28 +2730,32 @@ declare function getType(val: any): "string" | "number" | "bigint" | "boolean" |
 type NodeTypesWithoutComment = Node["type"] | keyof Aliases;
 type NodeTypes = NodeTypesWithoutComment | Comment["type"];
 type PrimitiveTypes = ReturnType<typeof getType>;
-type FieldDefinitions = {
-    [x: string]: FieldOptions;
-};
-type Validator = ({
+type FieldDefinitions = Record<string, FieldOptions>;
+type ValidatorImpl = (node?: Node, key?: string | {
+    toString(): string;
+}, val?: any) => void;
+type ValidatorType = {
     type: PrimitiveTypes;
-} | {
+} & ValidatorImpl;
+type ValidatorEach = {
     each: Validator;
-} | {
-    chainOf: Validator[];
-} | {
-    oneOf: any[];
-} | {
-    oneOfNodeTypes: NodeTypes[];
-} | {
-    oneOfNodeOrValueTypes: (NodeTypes | PrimitiveTypes)[];
-} | {
-    shapeOf: {
-        [x: string]: FieldOptions;
-    };
-} | object) & ((node: Node, key: string | {
-    toString(): string;
-}, val: any) => void);
+} & ValidatorImpl;
+type ValidatorChainOf = {
+    chainOf: readonly Validator[];
+} & ValidatorImpl;
+type ValidatorOneOf = {
+    oneOf: readonly any[];
+} & ValidatorImpl;
+type ValidatorOneOfNodeTypes = {
+    oneOfNodeTypes: readonly NodeTypes[];
+} & ValidatorImpl;
+type ValidatorOneOfNodeOrValueTypes = {
+    oneOfNodeOrValueTypes: readonly (NodeTypes | PrimitiveTypes)[];
+} & ValidatorImpl;
+type ValidatorShapeOf = {
+    shapeOf: Record<string, FieldOptions>;
+} & ValidatorImpl;
+type Validator = ValidatorType | ValidatorEach | ValidatorChainOf | ValidatorOneOf | ValidatorOneOfNodeTypes | ValidatorOneOfNodeOrValueTypes | ValidatorShapeOf | ValidatorImpl;
 type FieldOptions = {
     default?: string | number | boolean | [];
     optional?: boolean;
@@ -2768,7 +2771,7 @@ declare const DEPRECATED_ALIASES: {
     ModuleDeclaration: string;
 };
 
-declare const TYPES: Array<string>;
+declare const TYPES: string[];
 //# sourceMappingURL=index.d.ts.map
 
 /**
@@ -2786,14 +2789,14 @@ declare function inherits<T extends Node | null | undefined>(child: T, parent: N
  */
 declare function prependToMemberExpression<T extends Pick<MemberExpression, "object" | "property">>(member: T, prepend: MemberExpression["object"]): T;
 
-type Options = {
+type Options$1 = {
     preserveComments?: boolean;
 };
 /**
  * Remove all of the _* properties from a node along with the additional metadata
  * properties like location data and raw token data.
  */
-declare function removeProperties(node: Node, opts?: Options): void;
+declare function removeProperties(node: Node, opts?: Options$1): void;
 
 declare function removePropertiesDeep<T extends Node>(tree: T, opts?: {
     preserveComments: boolean;
@@ -2802,7 +2805,7 @@ declare function removePropertiesDeep<T extends Node>(tree: T, opts?: {
 /**
  * Dedupe type annotations.
  */
-declare function removeTypeDuplicates(nodesIn: ReadonlyArray<FlowType | false | null | undefined>): FlowType[];
+declare function removeTypeDuplicates(nodesIn: readonly (FlowType | false | null | undefined)[]): FlowType[];
 
 /**
  * For the given node, generate a map from assignment id names to the identifier node.
@@ -2813,9 +2816,9 @@ declare function removeTypeDuplicates(nodesIn: ReadonlyArray<FlowType | false |
  */
 declare function getAssignmentIdentifiers(node: Node | Node[]): Record<string, Identifier>;
 
-declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean, newBindingsOnly?: boolean): Record<string, Array<Identifier>>;
+declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean, newBindingsOnly?: boolean): Record<string, Identifier[]>;
 declare function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean, newBindingsOnly?: boolean): Record<string, Identifier>;
-declare function getBindingIdentifiers(node: Node, duplicates?: boolean, outerOnly?: boolean, newBindingsOnly?: boolean): Record<string, Identifier> | Record<string, Array<Identifier>>;
+declare function getBindingIdentifiers(node: Node, duplicates?: boolean, outerOnly?: boolean, newBindingsOnly?: boolean): Record<string, Identifier> | Record<string, Identifier[]>;
 declare namespace getBindingIdentifiers {
     var keys: KeysMap;
 }
@@ -2828,9 +2831,9 @@ type KeysMap = {
 //# sourceMappingURL=getBindingIdentifiers.d.ts.map
 
 declare const _default: {
-    (node: Node, duplicates: true): Record<string, Array<Identifier>>;
+    (node: Node, duplicates: true): Record<string, Identifier[]>;
     (node: Node, duplicates?: false): Record<string, Identifier>;
-    (node: Node, duplicates?: boolean): Record<string, Identifier> | Record<string, Array<Identifier>>;
+    (node: Node, duplicates?: boolean): Record<string, Identifier> | Record<string, Identifier[]>;
 };
 //# sourceMappingURL=getOuterBindingIdentifiers.d.ts.map
 
@@ -2841,11 +2844,11 @@ type GetFunctionNameResult = {
 declare function getFunctionName(node: ObjectMethod | ClassMethod): GetFunctionNameResult;
 declare function getFunctionName(node: Function | Class, parent: Node): GetFunctionNameResult;
 
-type TraversalAncestors = Array<{
+type TraversalAncestors = {
     node: Node;
     key: string;
     index?: number;
-}>;
+}[];
 type TraversalHandler<T> = (this: undefined, node: Node, parent: TraversalAncestors, state: T) => void;
 type TraversalHandlers<T> = {
     enter?: TraversalHandler<T>;
@@ -2891,7 +2894,7 @@ declare function isBinding(node: Node, parent: Node, grandparent?: Node): boolea
 /**
  * Check if the input `node` is block scoped.
  */
-declare function isBlockScoped(node: Node): boolean;
+declare function isBlockScoped(node: Node | null | undefined): boolean;
 
 /**
  * Check if the input `node` is definitely immutable.
@@ -2918,12 +2921,12 @@ declare function isPlaceholderType(placeholderType: string, targetType: string):
 /**
  * Check if the input `node` is a reference to a bound variable.
  */
-declare function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean;
+declare function isReferenced(node: Node | null | undefined, parent: Node, grandparent?: Node): boolean;
 
 /**
  * Check if the input `node` is a scope.
  */
-declare function isScope(node: Node, parent: Node): boolean;
+declare function isScope(node: Node | null | undefined, parent: Node): boolean;
 
 /**
  * Check if the input `specifier` is a `default` import or export.
@@ -2949,7 +2952,7 @@ declare function isValidIdentifier(name: string, reserved?: boolean): boolean;
 /**
  * Check if the input `node` is a variable declaration.
  */
-declare function isVar(node: Node): boolean;
+declare function isVar(node: Node | null | undefined): boolean;
 
 /**
  * Determines whether or not the input node `member` matches the
@@ -2971,331 +2974,637 @@ declare function validate(node: Node | undefined | null, key: string, val: unkno
  */
 declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (member: Node) => boolean;
 
-type Opts<Obj> = Partial<{
-    [Prop in keyof Obj]: Obj[Prop] extends Node ? Node : Obj[Prop] extends Node[] ? Node[] : Obj[Prop];
+type Options<Obj> = Partial<{
+    [Prop in Exclude<keyof Obj, "type">]: Obj[Prop] extends Node ? Node : Obj[Prop] extends Node[] ? Node[] : Obj[Prop];
 }>;
-declare function isArrayExpression(node: Node | null | undefined, opts?: Opts<ArrayExpression> | null): node is ArrayExpression;
-declare function isAssignmentExpression(node: Node | null | undefined, opts?: Opts<AssignmentExpression> | null): node is AssignmentExpression;
-declare function isBinaryExpression(node: Node | null | undefined, opts?: Opts<BinaryExpression> | null): node is BinaryExpression;
-declare function isInterpreterDirective(node: Node | null | undefined, opts?: Opts<InterpreterDirective> | null): node is InterpreterDirective;
-declare function isDirective(node: Node | null | undefined, opts?: Opts<Directive> | null): node is Directive;
-declare function isDirectiveLiteral(node: Node | null | undefined, opts?: Opts<DirectiveLiteral> | null): node is DirectiveLiteral;
-declare function isBlockStatement(node: Node | null | undefined, opts?: Opts<BlockStatement> | null): node is BlockStatement;
-declare function isBreakStatement(node: Node | null | undefined, opts?: Opts<BreakStatement> | null): node is BreakStatement;
-declare function isCallExpression(node: Node | null | undefined, opts?: Opts<CallExpression> | null): node is CallExpression;
-declare function isCatchClause(node: Node | null | undefined, opts?: Opts<CatchClause> | null): node is CatchClause;
-declare function isConditionalExpression(node: Node | null | undefined, opts?: Opts<ConditionalExpression> | null): node is ConditionalExpression;
-declare function isContinueStatement(node: Node | null | undefined, opts?: Opts<ContinueStatement> | null): node is ContinueStatement;
-declare function isDebuggerStatement(node: Node | null | undefined, opts?: Opts<DebuggerStatement> | null): node is DebuggerStatement;
-declare function isDoWhileStatement(node: Node | null | undefined, opts?: Opts<DoWhileStatement> | null): node is DoWhileStatement;
-declare function isEmptyStatement(node: Node | null | undefined, opts?: Opts<EmptyStatement> | null): node is EmptyStatement;
-declare function isExpressionStatement(node: Node | null | undefined, opts?: Opts<ExpressionStatement> | null): node is ExpressionStatement;
-declare function isFile(node: Node | null | undefined, opts?: Opts<File> | null): node is File;
-declare function isForInStatement(node: Node | null | undefined, opts?: Opts<ForInStatement> | null): node is ForInStatement;
-declare function isForStatement(node: Node | null | undefined, opts?: Opts<ForStatement> | null): node is ForStatement;
-declare function isFunctionDeclaration(node: Node | null | undefined, opts?: Opts<FunctionDeclaration> | null): node is FunctionDeclaration;
-declare function isFunctionExpression(node: Node | null | undefined, opts?: Opts<FunctionExpression> | null): node is FunctionExpression;
-declare function isIdentifier(node: Node | null | undefined, opts?: Opts<Identifier> | null): node is Identifier;
-declare function isIfStatement(node: Node | null | undefined, opts?: Opts<IfStatement> | null): node is IfStatement;
-declare function isLabeledStatement(node: Node | null | undefined, opts?: Opts<LabeledStatement> | null): node is LabeledStatement;
-declare function isStringLiteral(node: Node | null | undefined, opts?: Opts<StringLiteral> | null): node is StringLiteral;
-declare function isNumericLiteral(node: Node | null | undefined, opts?: Opts<NumericLiteral> | null): node is NumericLiteral;
-declare function isNullLiteral(node: Node | null | undefined, opts?: Opts<NullLiteral> | null): node is NullLiteral;
-declare function isBooleanLiteral(node: Node | null | undefined, opts?: Opts<BooleanLiteral> | null): node is BooleanLiteral;
-declare function isRegExpLiteral(node: Node | null | undefined, opts?: Opts<RegExpLiteral> | null): node is RegExpLiteral;
-declare function isLogicalExpression(node: Node | null | undefined, opts?: Opts<LogicalExpression> | null): node is LogicalExpression;
-declare function isMemberExpression(node: Node | null | undefined, opts?: Opts<MemberExpression> | null): node is MemberExpression;
-declare function isNewExpression(node: Node | null | undefined, opts?: Opts<NewExpression> | null): node is NewExpression;
-declare function isProgram(node: Node | null | undefined, opts?: Opts<Program> | null): node is Program;
-declare function isObjectExpression(node: Node | null | undefined, opts?: Opts<ObjectExpression> | null): node is ObjectExpression;
-declare function isObjectMethod(node: Node | null | undefined, opts?: Opts<ObjectMethod> | null): node is ObjectMethod;
-declare function isObjectProperty(node: Node | null | undefined, opts?: Opts<ObjectProperty> | null): node is ObjectProperty;
-declare function isRestElement(node: Node | null | undefined, opts?: Opts<RestElement> | null): node is RestElement;
-declare function isReturnStatement(node: Node | null | undefined, opts?: Opts<ReturnStatement> | null): node is ReturnStatement;
-declare function isSequenceExpression(node: Node | null | undefined, opts?: Opts<SequenceExpression> | null): node is SequenceExpression;
-declare function isParenthesizedExpression(node: Node | null | undefined, opts?: Opts<ParenthesizedExpression> | null): node is ParenthesizedExpression;
-declare function isSwitchCase(node: Node | null | undefined, opts?: Opts<SwitchCase> | null): node is SwitchCase;
-declare function isSwitchStatement(node: Node | null | undefined, opts?: Opts<SwitchStatement> | null): node is SwitchStatement;
-declare function isThisExpression(node: Node | null | undefined, opts?: Opts<ThisExpression> | null): node is ThisExpression;
-declare function isThrowStatement(node: Node | null | undefined, opts?: Opts<ThrowStatement> | null): node is ThrowStatement;
-declare function isTryStatement(node: Node | null | undefined, opts?: Opts<TryStatement> | null): node is TryStatement;
-declare function isUnaryExpression(node: Node | null | undefined, opts?: Opts<UnaryExpression> | null): node is UnaryExpression;
-declare function isUpdateExpression(node: Node | null | undefined, opts?: Opts<UpdateExpression> | null): node is UpdateExpression;
-declare function isVariableDeclaration(node: Node | null | undefined, opts?: Opts<VariableDeclaration> | null): node is VariableDeclaration;
-declare function isVariableDeclarator(node: Node | null | undefined, opts?: Opts<VariableDeclarator> | null): node is VariableDeclarator;
-declare function isWhileStatement(node: Node | null | undefined, opts?: Opts<WhileStatement> | null): node is WhileStatement;
-declare function isWithStatement(node: Node | null | undefined, opts?: Opts<WithStatement> | null): node is WithStatement;
-declare function isAssignmentPattern(node: Node | null | undefined, opts?: Opts<AssignmentPattern> | null): node is AssignmentPattern;
-declare function isArrayPattern(node: Node | null | undefined, opts?: Opts<ArrayPattern> | null): node is ArrayPattern;
-declare function isArrowFunctionExpression(node: Node | null | undefined, opts?: Opts<ArrowFunctionExpression> | null): node is ArrowFunctionExpression;
-declare function isClassBody(node: Node | null | undefined, opts?: Opts<ClassBody> | null): node is ClassBody;
-declare function isClassExpression(node: Node | null | undefined, opts?: Opts<ClassExpression> | null): node is ClassExpression;
-declare function isClassDeclaration(node: Node | null | undefined, opts?: Opts<ClassDeclaration> | null): node is ClassDeclaration;
-declare function isExportAllDeclaration(node: Node | null | undefined, opts?: Opts<ExportAllDeclaration> | null): node is ExportAllDeclaration;
-declare function isExportDefaultDeclaration(node: Node | null | undefined, opts?: Opts<ExportDefaultDeclaration> | null): node is ExportDefaultDeclaration;
-declare function isExportNamedDeclaration(node: Node | null | undefined, opts?: Opts<ExportNamedDeclaration> | null): node is ExportNamedDeclaration;
-declare function isExportSpecifier(node: Node | null | undefined, opts?: Opts<ExportSpecifier> | null): node is ExportSpecifier;
-declare function isForOfStatement(node: Node | null | undefined, opts?: Opts<ForOfStatement> | null): node is ForOfStatement;
-declare function isImportDeclaration(node: Node | null | undefined, opts?: Opts<ImportDeclaration> | null): node is ImportDeclaration;
-declare function isImportDefaultSpecifier(node: Node | null | undefined, opts?: Opts<ImportDefaultSpecifier> | null): node is ImportDefaultSpecifier;
-declare function isImportNamespaceSpecifier(node: Node | null | undefined, opts?: Opts<ImportNamespaceSpecifier> | null): node is ImportNamespaceSpecifier;
-declare function isImportSpecifier(node: Node | null | undefined, opts?: Opts<ImportSpecifier> | null): node is ImportSpecifier;
-declare function isImportExpression(node: Node | null | undefined, opts?: Opts<ImportExpression> | null): node is ImportExpression;
-declare function isMetaProperty(node: Node | null | undefined, opts?: Opts<MetaProperty> | null): node is MetaProperty;
-declare function isClassMethod(node: Node | null | undefined, opts?: Opts<ClassMethod> | null): node is ClassMethod;
-declare function isObjectPattern(node: Node | null | undefined, opts?: Opts<ObjectPattern> | null): node is ObjectPattern;
-declare function isSpreadElement(node: Node | null | undefined, opts?: Opts<SpreadElement> | null): node is SpreadElement;
-declare function isSuper(node: Node | null | undefined, opts?: Opts<Super> | null): node is Super;
-declare function isTaggedTemplateExpression(node: Node | null | undefined, opts?: Opts<TaggedTemplateExpression> | null): node is TaggedTemplateExpression;
-declare function isTemplateElement(node: Node | null | undefined, opts?: Opts<TemplateElement> | null): node is TemplateElement;
-declare function isTemplateLiteral(node: Node | null | undefined, opts?: Opts<TemplateLiteral> | null): node is TemplateLiteral;
-declare function isYieldExpression(node: Node | null | undefined, opts?: Opts<YieldExpression> | null): node is YieldExpression;
-declare function isAwaitExpression(node: Node | null | undefined, opts?: Opts<AwaitExpression> | null): node is AwaitExpression;
-declare function isImport(node: Node | null | undefined, opts?: Opts<Import> | null): node is Import;
-declare function isBigIntLiteral(node: Node | null | undefined, opts?: Opts<BigIntLiteral> | null): node is BigIntLiteral;
-declare function isExportNamespaceSpecifier(node: Node | null | undefined, opts?: Opts<ExportNamespaceSpecifier> | null): node is ExportNamespaceSpecifier;
-declare function isOptionalMemberExpression(node: Node | null | undefined, opts?: Opts<OptionalMemberExpression> | null): node is OptionalMemberExpression;
-declare function isOptionalCallExpression(node: Node | null | undefined, opts?: Opts<OptionalCallExpression> | null): node is OptionalCallExpression;
-declare function isClassProperty(node: Node | null | undefined, opts?: Opts<ClassProperty> | null): node is ClassProperty;
-declare function isClassAccessorProperty(node: Node | null | undefined, opts?: Opts<ClassAccessorProperty> | null): node is ClassAccessorProperty;
-declare function isClassPrivateProperty(node: Node | null | undefined, opts?: Opts<ClassPrivateProperty> | null): node is ClassPrivateProperty;
-declare function isClassPrivateMethod(node: Node | null | undefined, opts?: Opts<ClassPrivateMethod> | null): node is ClassPrivateMethod;
-declare function isPrivateName(node: Node | null | undefined, opts?: Opts<PrivateName> | null): node is PrivateName;
-declare function isStaticBlock(node: Node | null | undefined, opts?: Opts<StaticBlock> | null): node is StaticBlock;
-declare function isImportAttribute(node: Node | null | undefined, opts?: Opts<ImportAttribute> | null): node is ImportAttribute;
-declare function isAnyTypeAnnotation(node: Node | null | undefined, opts?: Opts<AnyTypeAnnotation> | null): node is AnyTypeAnnotation;
-declare function isArrayTypeAnnotation(node: Node | null | undefined, opts?: Opts<ArrayTypeAnnotation> | null): node is ArrayTypeAnnotation;
-declare function isBooleanTypeAnnotation(node: Node | null | undefined, opts?: Opts<BooleanTypeAnnotation> | null): node is BooleanTypeAnnotation;
-declare function isBooleanLiteralTypeAnnotation(node: Node | null | undefined, opts?: Opts<BooleanLiteralTypeAnnotation> | null): node is BooleanLiteralTypeAnnotation;
-declare function isNullLiteralTypeAnnotation(node: Node | null | undefined, opts?: Opts<NullLiteralTypeAnnotation> | null): node is NullLiteralTypeAnnotation;
-declare function isClassImplements(node: Node | null | undefined, opts?: Opts<ClassImplements> | null): node is ClassImplements;
-declare function isDeclareClass(node: Node | null | undefined, opts?: Opts<DeclareClass> | null): node is DeclareClass;
-declare function isDeclareFunction(node: Node | null | undefined, opts?: Opts<DeclareFunction> | null): node is DeclareFunction;
-declare function isDeclareInterface(node: Node | null | undefined, opts?: Opts<DeclareInterface> | null): node is DeclareInterface;
-declare function isDeclareModule(node: Node | null | undefined, opts?: Opts<DeclareModule> | null): node is DeclareModule;
-declare function isDeclareModuleExports(node: Node | null | undefined, opts?: Opts<DeclareModuleExports> | null): node is DeclareModuleExports;
-declare function isDeclareTypeAlias(node: Node | null | undefined, opts?: Opts<DeclareTypeAlias> | null): node is DeclareTypeAlias;
-declare function isDeclareOpaqueType(node: Node | null | undefined, opts?: Opts<DeclareOpaqueType> | null): node is DeclareOpaqueType;
-declare function isDeclareVariable(node: Node | null | undefined, opts?: Opts<DeclareVariable> | null): node is DeclareVariable;
-declare function isDeclareExportDeclaration(node: Node | null | undefined, opts?: Opts<DeclareExportDeclaration> | null): node is DeclareExportDeclaration;
-declare function isDeclareExportAllDeclaration(node: Node | null | undefined, opts?: Opts<DeclareExportAllDeclaration> | null): node is DeclareExportAllDeclaration;
-declare function isDeclaredPredicate(node: Node | null | undefined, opts?: Opts<DeclaredPredicate> | null): node is DeclaredPredicate;
-declare function isExistsTypeAnnotation(node: Node | null | undefined, opts?: Opts<ExistsTypeAnnotation> | null): node is ExistsTypeAnnotation;
-declare function isFunctionTypeAnnotation(node: Node | null | undefined, opts?: Opts<FunctionTypeAnnotation> | null): node is FunctionTypeAnnotation;
-declare function isFunctionTypeParam(node: Node | null | undefined, opts?: Opts<FunctionTypeParam> | null): node is FunctionTypeParam;
-declare function isGenericTypeAnnotation(node: Node | null | undefined, opts?: Opts<GenericTypeAnnotation> | null): node is GenericTypeAnnotation;
-declare function isInferredPredicate(node: Node | null | undefined, opts?: Opts<InferredPredicate> | null): node is InferredPredicate;
-declare function isInterfaceExtends(node: Node | null | undefined, opts?: Opts<InterfaceExtends> | null): node is InterfaceExtends;
-declare function isInterfaceDeclaration(node: Node | null | undefined, opts?: Opts<InterfaceDeclaration> | null): node is InterfaceDeclaration;
-declare function isInterfaceTypeAnnotation(node: Node | null | undefined, opts?: Opts<InterfaceTypeAnnotation> | null): node is InterfaceTypeAnnotation;
-declare function isIntersectionTypeAnnotation(node: Node | null | undefined, opts?: Opts<IntersectionTypeAnnotation> | null): node is IntersectionTypeAnnotation;
-declare function isMixedTypeAnnotation(node: Node | null | undefined, opts?: Opts<MixedTypeAnnotation> | null): node is MixedTypeAnnotation;
-declare function isEmptyTypeAnnotation(node: Node | null | undefined, opts?: Opts<EmptyTypeAnnotation> | null): node is EmptyTypeAnnotation;
-declare function isNullableTypeAnnotation(node: Node | null | undefined, opts?: Opts<NullableTypeAnnotation> | null): node is NullableTypeAnnotation;
-declare function isNumberLiteralTypeAnnotation(node: Node | null | undefined, opts?: Opts<NumberLiteralTypeAnnotation> | null): node is NumberLiteralTypeAnnotation;
-declare function isNumberTypeAnnotation(node: Node | null | undefined, opts?: Opts<NumberTypeAnnotation> | null): node is NumberTypeAnnotation;
-declare function isObjectTypeAnnotation(node: Node | null | undefined, opts?: Opts<ObjectTypeAnnotation> | null): node is ObjectTypeAnnotation;
-declare function isObjectTypeInternalSlot(node: Node | null | undefined, opts?: Opts<ObjectTypeInternalSlot> | null): node is ObjectTypeInternalSlot;
-declare function isObjectTypeCallProperty(node: Node | null | undefined, opts?: Opts<ObjectTypeCallProperty> | null): node is ObjectTypeCallProperty;
-declare function isObjectTypeIndexer(node: Node | null | undefined, opts?: Opts<ObjectTypeIndexer> | null): node is ObjectTypeIndexer;
-declare function isObjectTypeProperty(node: Node | null | undefined, opts?: Opts<ObjectTypeProperty> | null): node is ObjectTypeProperty;
-declare function isObjectTypeSpreadProperty(node: Node | null | undefined, opts?: Opts<ObjectTypeSpreadProperty> | null): node is ObjectTypeSpreadProperty;
-declare function isOpaqueType(node: Node | null | undefined, opts?: Opts<OpaqueType> | null): node is OpaqueType;
-declare function isQualifiedTypeIdentifier(node: Node | null | undefined, opts?: Opts<QualifiedTypeIdentifier> | null): node is QualifiedTypeIdentifier;
-declare function isStringLiteralTypeAnnotation(node: Node | null | undefined, opts?: Opts<StringLiteralTypeAnnotation> | null): node is StringLiteralTypeAnnotation;
-declare function isStringTypeAnnotation(node: Node | null | undefined, opts?: Opts<StringTypeAnnotation> | null): node is StringTypeAnnotation;
-declare function isSymbolTypeAnnotation(node: Node | null | undefined, opts?: Opts<SymbolTypeAnnotation> | null): node is SymbolTypeAnnotation;
-declare function isThisTypeAnnotation(node: Node | null | undefined, opts?: Opts<ThisTypeAnnotation> | null): node is ThisTypeAnnotation;
-declare function isTupleTypeAnnotation(node: Node | null | undefined, opts?: Opts<TupleTypeAnnotation> | null): node is TupleTypeAnnotation;
-declare function isTypeofTypeAnnotation(node: Node | null | undefined, opts?: Opts<TypeofTypeAnnotation> | null): node is TypeofTypeAnnotation;
-declare function isTypeAlias(node: Node | null | undefined, opts?: Opts<TypeAlias> | null): node is TypeAlias;
-declare function isTypeAnnotation(node: Node | null | undefined, opts?: Opts<TypeAnnotation> | null): node is TypeAnnotation;
-declare function isTypeCastExpression(node: Node | null | undefined, opts?: Opts<TypeCastExpression> | null): node is TypeCastExpression;
-declare function isTypeParameter(node: Node | null | undefined, opts?: Opts<TypeParameter> | null): node is TypeParameter;
-declare function isTypeParameterDeclaration(node: Node | null | undefined, opts?: Opts<TypeParameterDeclaration> | null): node is TypeParameterDeclaration;
-declare function isTypeParameterInstantiation(node: Node | null | undefined, opts?: Opts<TypeParameterInstantiation> | null): node is TypeParameterInstantiation;
-declare function isUnionTypeAnnotation(node: Node | null | undefined, opts?: Opts<UnionTypeAnnotation> | null): node is UnionTypeAnnotation;
-declare function isVariance(node: Node | null | undefined, opts?: Opts<Variance> | null): node is Variance;
-declare function isVoidTypeAnnotation(node: Node | null | undefined, opts?: Opts<VoidTypeAnnotation> | null): node is VoidTypeAnnotation;
-declare function isEnumDeclaration(node: Node | null | undefined, opts?: Opts<EnumDeclaration> | null): node is EnumDeclaration;
-declare function isEnumBooleanBody(node: Node | null | undefined, opts?: Opts<EnumBooleanBody> | null): node is EnumBooleanBody;
-declare function isEnumNumberBody(node: Node | null | undefined, opts?: Opts<EnumNumberBody> | null): node is EnumNumberBody;
-declare function isEnumStringBody(node: Node | null | undefined, opts?: Opts<EnumStringBody> | null): node is EnumStringBody;
-declare function isEnumSymbolBody(node: Node | null | undefined, opts?: Opts<EnumSymbolBody> | null): node is EnumSymbolBody;
-declare function isEnumBooleanMember(node: Node | null | undefined, opts?: Opts<EnumBooleanMember> | null): node is EnumBooleanMember;
-declare function isEnumNumberMember(node: Node | null | undefined, opts?: Opts<EnumNumberMember> | null): node is EnumNumberMember;
-declare function isEnumStringMember(node: Node | null | undefined, opts?: Opts<EnumStringMember> | null): node is EnumStringMember;
-declare function isEnumDefaultedMember(node: Node | null | undefined, opts?: Opts<EnumDefaultedMember> | null): node is EnumDefaultedMember;
-declare function isIndexedAccessType(node: Node | null | undefined, opts?: Opts<IndexedAccessType> | null): node is IndexedAccessType;
-declare function isOptionalIndexedAccessType(node: Node | null | undefined, opts?: Opts<OptionalIndexedAccessType> | null): node is OptionalIndexedAccessType;
-declare function isJSXAttribute(node: Node | null | undefined, opts?: Opts<JSXAttribute> | null): node is JSXAttribute;
-declare function isJSXClosingElement(node: Node | null | undefined, opts?: Opts<JSXClosingElement> | null): node is JSXClosingElement;
-declare function isJSXElement(node: Node | null | undefined, opts?: Opts<JSXElement> | null): node is JSXElement;
-declare function isJSXEmptyExpression(node: Node | null | undefined, opts?: Opts<JSXEmptyExpression> | null): node is JSXEmptyExpression;
-declare function isJSXExpressionContainer(node: Node | null | undefined, opts?: Opts<JSXExpressionContainer> | null): node is JSXExpressionContainer;
-declare function isJSXSpreadChild(node: Node | null | undefined, opts?: Opts<JSXSpreadChild> | null): node is JSXSpreadChild;
-declare function isJSXIdentifier(node: Node | null | undefined, opts?: Opts<JSXIdentifier> | null): node is JSXIdentifier;
-declare function isJSXMemberExpression(node: Node | null | undefined, opts?: Opts<JSXMemberExpression> | null): node is JSXMemberExpression;
-declare function isJSXNamespacedName(node: Node | null | undefined, opts?: Opts<JSXNamespacedName> | null): node is JSXNamespacedName;
-declare function isJSXOpeningElement(node: Node | null | undefined, opts?: Opts<JSXOpeningElement> | null): node is JSXOpeningElement;
-declare function isJSXSpreadAttribute(node: Node | null | undefined, opts?: Opts<JSXSpreadAttribute> | null): node is JSXSpreadAttribute;
-declare function isJSXText(node: Node | null | undefined, opts?: Opts<JSXText> | null): node is JSXText;
-declare function isJSXFragment(node: Node | null | undefined, opts?: Opts<JSXFragment> | null): node is JSXFragment;
-declare function isJSXOpeningFragment(node: Node | null | undefined, opts?: Opts<JSXOpeningFragment> | null): node is JSXOpeningFragment;
-declare function isJSXClosingFragment(node: Node | null | undefined, opts?: Opts<JSXClosingFragment> | null): node is JSXClosingFragment;
-declare function isNoop(node: Node | null | undefined, opts?: Opts<Noop> | null): node is Noop;
-declare function isPlaceholder(node: Node | null | undefined, opts?: Opts<Placeholder> | null): node is Placeholder;
-declare function isV8IntrinsicIdentifier(node: Node | null | undefined, opts?: Opts<V8IntrinsicIdentifier> | null): node is V8IntrinsicIdentifier;
-declare function isArgumentPlaceholder(node: Node | null | undefined, opts?: Opts<ArgumentPlaceholder> | null): node is ArgumentPlaceholder;
-declare function isBindExpression(node: Node | null | undefined, opts?: Opts<BindExpression> | null): node is BindExpression;
-declare function isDecorator(node: Node | null | undefined, opts?: Opts<Decorator> | null): node is Decorator;
-declare function isDoExpression(node: Node | null | undefined, opts?: Opts<DoExpression> | null): node is DoExpression;
-declare function isExportDefaultSpecifier(node: Node | null | undefined, opts?: Opts<ExportDefaultSpecifier> | null): node is ExportDefaultSpecifier;
-declare function isRecordExpression(node: Node | null | undefined, opts?: Opts<RecordExpression> | null): node is RecordExpression;
-declare function isTupleExpression(node: Node | null | undefined, opts?: Opts<TupleExpression> | null): node is TupleExpression;
-declare function isDecimalLiteral(node: Node | null | undefined, opts?: Opts<DecimalLiteral> | null): node is DecimalLiteral;
-declare function isModuleExpression(node: Node | null | undefined, opts?: Opts<ModuleExpression> | null): node is ModuleExpression;
-declare function isTopicReference(node: Node | null | undefined, opts?: Opts<TopicReference> | null): node is TopicReference;
-declare function isPipelineTopicExpression(node: Node | null | undefined, opts?: Opts<PipelineTopicExpression> | null): node is PipelineTopicExpression;
-declare function isPipelineBareFunction(node: Node | null | undefined, opts?: Opts<PipelineBareFunction> | null): node is PipelineBareFunction;
-declare function isPipelinePrimaryTopicReference(node: Node | null | undefined, opts?: Opts<PipelinePrimaryTopicReference> | null): node is PipelinePrimaryTopicReference;
-declare function isVoidPattern(node: Node | null | undefined, opts?: Opts<VoidPattern> | null): node is VoidPattern;
-declare function isTSParameterProperty(node: Node | null | undefined, opts?: Opts<TSParameterProperty> | null): node is TSParameterProperty;
-declare function isTSDeclareFunction(node: Node | null | undefined, opts?: Opts<TSDeclareFunction> | null): node is TSDeclareFunction;
-declare function isTSDeclareMethod(node: Node | null | undefined, opts?: Opts<TSDeclareMethod> | null): node is TSDeclareMethod;
-declare function isTSQualifiedName(node: Node | null | undefined, opts?: Opts<TSQualifiedName> | null): node is TSQualifiedName;
-declare function isTSCallSignatureDeclaration(node: Node | null | undefined, opts?: Opts<TSCallSignatureDeclaration> | null): node is TSCallSignatureDeclaration;
-declare function isTSConstructSignatureDeclaration(node: Node | null | undefined, opts?: Opts<TSConstructSignatureDeclaration> | null): node is TSConstructSignatureDeclaration;
-declare function isTSPropertySignature(node: Node | null | undefined, opts?: Opts<TSPropertySignature> | null): node is TSPropertySignature;
-declare function isTSMethodSignature(node: Node | null | undefined, opts?: Opts<TSMethodSignature> | null): node is TSMethodSignature;
-declare function isTSIndexSignature(node: Node | null | undefined, opts?: Opts<TSIndexSignature> | null): node is TSIndexSignature;
-declare function isTSAnyKeyword(node: Node | null | undefined, opts?: Opts<TSAnyKeyword> | null): node is TSAnyKeyword;
-declare function isTSBooleanKeyword(node: Node | null | undefined, opts?: Opts<TSBooleanKeyword> | null): node is TSBooleanKeyword;
-declare function isTSBigIntKeyword(node: Node | null | undefined, opts?: Opts<TSBigIntKeyword> | null): node is TSBigIntKeyword;
-declare function isTSIntrinsicKeyword(node: Node | null | undefined, opts?: Opts<TSIntrinsicKeyword> | null): node is TSIntrinsicKeyword;
-declare function isTSNeverKeyword(node: Node | null | undefined, opts?: Opts<TSNeverKeyword> | null): node is TSNeverKeyword;
-declare function isTSNullKeyword(node: Node | null | undefined, opts?: Opts<TSNullKeyword> | null): node is TSNullKeyword;
-declare function isTSNumberKeyword(node: Node | null | undefined, opts?: Opts<TSNumberKeyword> | null): node is TSNumberKeyword;
-declare function isTSObjectKeyword(node: Node | null | undefined, opts?: Opts<TSObjectKeyword> | null): node is TSObjectKeyword;
-declare function isTSStringKeyword(node: Node | null | undefined, opts?: Opts<TSStringKeyword> | null): node is TSStringKeyword;
-declare function isTSSymbolKeyword(node: Node | null | undefined, opts?: Opts<TSSymbolKeyword> | null): node is TSSymbolKeyword;
-declare function isTSUndefinedKeyword(node: Node | null | undefined, opts?: Opts<TSUndefinedKeyword> | null): node is TSUndefinedKeyword;
-declare function isTSUnknownKeyword(node: Node | null | undefined, opts?: Opts<TSUnknownKeyword> | null): node is TSUnknownKeyword;
-declare function isTSVoidKeyword(node: Node | null | undefined, opts?: Opts<TSVoidKeyword> | null): node is TSVoidKeyword;
-declare function isTSThisType(node: Node | null | undefined, opts?: Opts<TSThisType> | null): node is TSThisType;
-declare function isTSFunctionType(node: Node | null | undefined, opts?: Opts<TSFunctionType> | null): node is TSFunctionType;
-declare function isTSConstructorType(node: Node | null | undefined, opts?: Opts<TSConstructorType> | null): node is TSConstructorType;
-declare function isTSTypeReference(node: Node | null | undefined, opts?: Opts<TSTypeReference> | null): node is TSTypeReference;
-declare function isTSTypePredicate(node: Node | null | undefined, opts?: Opts<TSTypePredicate> | null): node is TSTypePredicate;
-declare function isTSTypeQuery(node: Node | null | undefined, opts?: Opts<TSTypeQuery> | null): node is TSTypeQuery;
-declare function isTSTypeLiteral(node: Node | null | undefined, opts?: Opts<TSTypeLiteral> | null): node is TSTypeLiteral;
-declare function isTSArrayType(node: Node | null | undefined, opts?: Opts<TSArrayType> | null): node is TSArrayType;
-declare function isTSTupleType(node: Node | null | undefined, opts?: Opts<TSTupleType> | null): node is TSTupleType;
-declare function isTSOptionalType(node: Node | null | undefined, opts?: Opts<TSOptionalType> | null): node is TSOptionalType;
-declare function isTSRestType(node: Node | null | undefined, opts?: Opts<TSRestType> | null): node is TSRestType;
-declare function isTSNamedTupleMember(node: Node | null | undefined, opts?: Opts<TSNamedTupleMember> | null): node is TSNamedTupleMember;
-declare function isTSUnionType(node: Node | null | undefined, opts?: Opts<TSUnionType> | null): node is TSUnionType;
-declare function isTSIntersectionType(node: Node | null | undefined, opts?: Opts<TSIntersectionType> | null): node is TSIntersectionType;
-declare function isTSConditionalType(node: Node | null | undefined, opts?: Opts<TSConditionalType> | null): node is TSConditionalType;
-declare function isTSInferType(node: Node | null | undefined, opts?: Opts<TSInferType> | null): node is TSInferType;
-declare function isTSParenthesizedType(node: Node | null | undefined, opts?: Opts<TSParenthesizedType> | null): node is TSParenthesizedType;
-declare function isTSTypeOperator(node: Node | null | undefined, opts?: Opts<TSTypeOperator> | null): node is TSTypeOperator;
-declare function isTSIndexedAccessType(node: Node | null | undefined, opts?: Opts<TSIndexedAccessType> | null): node is TSIndexedAccessType;
-declare function isTSMappedType(node: Node | null | undefined, opts?: Opts<TSMappedType> | null): node is TSMappedType;
-declare function isTSTemplateLiteralType(node: Node | null | undefined, opts?: Opts<TSTemplateLiteralType> | null): node is TSTemplateLiteralType;
-declare function isTSLiteralType(node: Node | null | undefined, opts?: Opts<TSLiteralType> | null): node is TSLiteralType;
-declare function isTSExpressionWithTypeArguments(node: Node | null | undefined, opts?: Opts<TSExpressionWithTypeArguments> | null): node is TSExpressionWithTypeArguments;
-declare function isTSInterfaceDeclaration(node: Node | null | undefined, opts?: Opts<TSInterfaceDeclaration> | null): node is TSInterfaceDeclaration;
-declare function isTSInterfaceBody(node: Node | null | undefined, opts?: Opts<TSInterfaceBody> | null): node is TSInterfaceBody;
-declare function isTSTypeAliasDeclaration(node: Node | null | undefined, opts?: Opts<TSTypeAliasDeclaration> | null): node is TSTypeAliasDeclaration;
-declare function isTSInstantiationExpression(node: Node | null | undefined, opts?: Opts<TSInstantiationExpression> | null): node is TSInstantiationExpression;
-declare function isTSAsExpression(node: Node | null | undefined, opts?: Opts<TSAsExpression> | null): node is TSAsExpression;
-declare function isTSSatisfiesExpression(node: Node | null | undefined, opts?: Opts<TSSatisfiesExpression> | null): node is TSSatisfiesExpression;
-declare function isTSTypeAssertion(node: Node | null | undefined, opts?: Opts<TSTypeAssertion> | null): node is TSTypeAssertion;
-declare function isTSEnumBody(node: Node | null | undefined, opts?: Opts<TSEnumBody> | null): node is TSEnumBody;
-declare function isTSEnumDeclaration(node: Node | null | undefined, opts?: Opts<TSEnumDeclaration> | null): node is TSEnumDeclaration;
-declare function isTSEnumMember(node: Node | null | undefined, opts?: Opts<TSEnumMember> | null): node is TSEnumMember;
-declare function isTSModuleDeclaration(node: Node | null | undefined, opts?: Opts<TSModuleDeclaration> | null): node is TSModuleDeclaration;
-declare function isTSModuleBlock(node: Node | null | undefined, opts?: Opts<TSModuleBlock> | null): node is TSModuleBlock;
-declare function isTSImportType(node: Node | null | undefined, opts?: Opts<TSImportType> | null): node is TSImportType;
-declare function isTSImportEqualsDeclaration(node: Node | null | undefined, opts?: Opts<TSImportEqualsDeclaration> | null): node is TSImportEqualsDeclaration;
-declare function isTSExternalModuleReference(node: Node | null | undefined, opts?: Opts<TSExternalModuleReference> | null): node is TSExternalModuleReference;
-declare function isTSNonNullExpression(node: Node | null | undefined, opts?: Opts<TSNonNullExpression> | null): node is TSNonNullExpression;
-declare function isTSExportAssignment(node: Node | null | undefined, opts?: Opts<TSExportAssignment> | null): node is TSExportAssignment;
-declare function isTSNamespaceExportDeclaration(node: Node | null | undefined, opts?: Opts<TSNamespaceExportDeclaration> | null): node is TSNamespaceExportDeclaration;
-declare function isTSTypeAnnotation(node: Node | null | undefined, opts?: Opts<TSTypeAnnotation> | null): node is TSTypeAnnotation;
-declare function isTSTypeParameterInstantiation(node: Node | null | undefined, opts?: Opts<TSTypeParameterInstantiation> | null): node is TSTypeParameterInstantiation;
-declare function isTSTypeParameterDeclaration(node: Node | null | undefined, opts?: Opts<TSTypeParameterDeclaration> | null): node is TSTypeParameterDeclaration;
-declare function isTSTypeParameter(node: Node | null | undefined, opts?: Opts<TSTypeParameter> | null): node is TSTypeParameter;
-declare function isStandardized(node: Node | null | undefined, opts?: Opts<Standardized> | null): node is Standardized;
-declare function isExpression(node: Node | null | undefined, opts?: Opts<Expression> | null): node is Expression;
-declare function isBinary(node: Node | null | undefined, opts?: Opts<Binary> | null): node is Binary;
-declare function isScopable(node: Node | null | undefined, opts?: Opts<Scopable> | null): node is Scopable;
-declare function isBlockParent(node: Node | null | undefined, opts?: Opts<BlockParent> | null): node is BlockParent;
-declare function isBlock(node: Node | null | undefined, opts?: Opts<Block> | null): node is Block;
-declare function isStatement(node: Node | null | undefined, opts?: Opts<Statement> | null): node is Statement;
-declare function isTerminatorless(node: Node | null | undefined, opts?: Opts<Terminatorless> | null): node is Terminatorless;
-declare function isCompletionStatement(node: Node | null | undefined, opts?: Opts<CompletionStatement> | null): node is CompletionStatement;
-declare function isConditional(node: Node | null | undefined, opts?: Opts<Conditional> | null): node is Conditional;
-declare function isLoop(node: Node | null | undefined, opts?: Opts<Loop> | null): node is Loop;
-declare function isWhile(node: Node | null | undefined, opts?: Opts<While> | null): node is While;
-declare function isExpressionWrapper(node: Node | null | undefined, opts?: Opts<ExpressionWrapper> | null): node is ExpressionWrapper;
-declare function isFor(node: Node | null | undefined, opts?: Opts<For> | null): node is For;
-declare function isForXStatement(node: Node | null | undefined, opts?: Opts<ForXStatement> | null): node is ForXStatement;
-declare function isFunction(node: Node | null | undefined, opts?: Opts<Function> | null): node is Function;
-declare function isFunctionParent(node: Node | null | undefined, opts?: Opts<FunctionParent> | null): node is FunctionParent;
-declare function isPureish(node: Node | null | undefined, opts?: Opts<Pureish> | null): node is Pureish;
-declare function isDeclaration(node: Node | null | undefined, opts?: Opts<Declaration> | null): node is Declaration;
-declare function isFunctionParameter(node: Node | null | undefined, opts?: Opts<FunctionParameter> | null): node is FunctionParameter;
-declare function isPatternLike(node: Node | null | undefined, opts?: Opts<PatternLike> | null): node is PatternLike;
-declare function isLVal(node: Node | null | undefined, opts?: Opts<LVal> | null): node is LVal;
-declare function isTSEntityName(node: Node | null | undefined, opts?: Opts<TSEntityName> | null): node is TSEntityName;
-declare function isLiteral(node: Node | null | undefined, opts?: Opts<Literal> | null): node is Literal;
-declare function isUserWhitespacable(node: Node | null | undefined, opts?: Opts<UserWhitespacable> | null): node is UserWhitespacable;
-declare function isMethod(node: Node | null | undefined, opts?: Opts<Method> | null): node is Method;
-declare function isObjectMember(node: Node | null | undefined, opts?: Opts<ObjectMember> | null): node is ObjectMember;
-declare function isProperty(node: Node | null | undefined, opts?: Opts<Property> | null): node is Property;
-declare function isUnaryLike(node: Node | null | undefined, opts?: Opts<UnaryLike> | null): node is UnaryLike;
-declare function isPattern(node: Node | null | undefined, opts?: Opts<Pattern> | null): node is Pattern;
-declare function isClass(node: Node | null | undefined, opts?: Opts<Class> | null): node is Class;
-declare function isImportOrExportDeclaration(node: Node | null | undefined, opts?: Opts<ImportOrExportDeclaration> | null): node is ImportOrExportDeclaration;
-declare function isExportDeclaration(node: Node | null | undefined, opts?: Opts<ExportDeclaration> | null): node is ExportDeclaration;
-declare function isModuleSpecifier(node: Node | null | undefined, opts?: Opts<ModuleSpecifier> | null): node is ModuleSpecifier;
-declare function isAccessor(node: Node | null | undefined, opts?: Opts<Accessor> | null): node is Accessor;
-declare function isPrivate(node: Node | null | undefined, opts?: Opts<Private> | null): node is Private;
-declare function isFlow(node: Node | null | undefined, opts?: Opts<Flow> | null): node is Flow;
-declare function isFlowType(node: Node | null | undefined, opts?: Opts<FlowType> | null): node is FlowType;
-declare function isFlowBaseAnnotation(node: Node | null | undefined, opts?: Opts<FlowBaseAnnotation> | null): node is FlowBaseAnnotation;
-declare function isFlowDeclaration(node: Node | null | undefined, opts?: Opts<FlowDeclaration> | null): node is FlowDeclaration;
-declare function isFlowPredicate(node: Node | null | undefined, opts?: Opts<FlowPredicate> | null): node is FlowPredicate;
-declare function isEnumBody(node: Node | null | undefined, opts?: Opts<EnumBody> | null): node is EnumBody;
-declare function isEnumMember(node: Node | null | undefined, opts?: Opts<EnumMember> | null): node is EnumMember;
-declare function isJSX(node: Node | null | undefined, opts?: Opts<JSX> | null): node is JSX;
-declare function isMiscellaneous(node: Node | null | undefined, opts?: Opts<Miscellaneous> | null): node is Miscellaneous;
-declare function isTypeScript(node: Node | null | undefined, opts?: Opts<TypeScript> | null): node is TypeScript;
-declare function isTSTypeElement(node: Node | null | undefined, opts?: Opts<TSTypeElement> | null): node is TSTypeElement;
-declare function isTSType(node: Node | null | undefined, opts?: Opts<TSType> | null): node is TSType;
-declare function isTSBaseType(node: Node | null | undefined, opts?: Opts<TSBaseType> | null): node is TSBaseType;
+declare function isArrayExpression(node: Node | null | undefined): node is ArrayExpression;
+declare function isArrayExpression<Opts extends Options<ArrayExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ArrayExpression & Opts;
+declare function isAssignmentExpression(node: Node | null | undefined): node is AssignmentExpression;
+declare function isAssignmentExpression<Opts extends Options<AssignmentExpression>>(node: Node | null | undefined, opts?: Opts | null): node is AssignmentExpression & Opts;
+declare function isBinaryExpression(node: Node | null | undefined): node is BinaryExpression;
+declare function isBinaryExpression<Opts extends Options<BinaryExpression>>(node: Node | null | undefined, opts?: Opts | null): node is BinaryExpression & Opts;
+declare function isInterpreterDirective(node: Node | null | undefined): node is InterpreterDirective;
+declare function isInterpreterDirective<Opts extends Options<InterpreterDirective>>(node: Node | null | undefined, opts?: Opts | null): node is InterpreterDirective & Opts;
+declare function isDirective(node: Node | null | undefined): node is Directive;
+declare function isDirective<Opts extends Options<Directive>>(node: Node | null | undefined, opts?: Opts | null): node is Directive & Opts;
+declare function isDirectiveLiteral(node: Node | null | undefined): node is DirectiveLiteral;
+declare function isDirectiveLiteral<Opts extends Options<DirectiveLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is DirectiveLiteral & Opts;
+declare function isBlockStatement(node: Node | null | undefined): node is BlockStatement;
+declare function isBlockStatement<Opts extends Options<BlockStatement>>(node: Node | null | undefined, opts?: Opts | null): node is BlockStatement & Opts;
+declare function isBreakStatement(node: Node | null | undefined): node is BreakStatement;
+declare function isBreakStatement<Opts extends Options<BreakStatement>>(node: Node | null | undefined, opts?: Opts | null): node is BreakStatement & Opts;
+declare function isCallExpression(node: Node | null | undefined): node is CallExpression;
+declare function isCallExpression<Opts extends Options<CallExpression>>(node: Node | null | undefined, opts?: Opts | null): node is CallExpression & Opts;
+declare function isCatchClause(node: Node | null | undefined): node is CatchClause;
+declare function isCatchClause<Opts extends Options<CatchClause>>(node: Node | null | undefined, opts?: Opts | null): node is CatchClause & Opts;
+declare function isConditionalExpression(node: Node | null | undefined): node is ConditionalExpression;
+declare function isConditionalExpression<Opts extends Options<ConditionalExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ConditionalExpression & Opts;
+declare function isContinueStatement(node: Node | null | undefined): node is ContinueStatement;
+declare function isContinueStatement<Opts extends Options<ContinueStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ContinueStatement & Opts;
+declare function isDebuggerStatement(node: Node | null | undefined): node is DebuggerStatement;
+declare function isDebuggerStatement<Opts extends Options<DebuggerStatement>>(node: Node | null | undefined, opts?: Opts | null): node is DebuggerStatement & Opts;
+declare function isDoWhileStatement(node: Node | null | undefined): node is DoWhileStatement;
+declare function isDoWhileStatement<Opts extends Options<DoWhileStatement>>(node: Node | null | undefined, opts?: Opts | null): node is DoWhileStatement & Opts;
+declare function isEmptyStatement(node: Node | null | undefined): node is EmptyStatement;
+declare function isEmptyStatement<Opts extends Options<EmptyStatement>>(node: Node | null | undefined, opts?: Opts | null): node is EmptyStatement & Opts;
+declare function isExpressionStatement(node: Node | null | undefined): node is ExpressionStatement;
+declare function isExpressionStatement<Opts extends Options<ExpressionStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ExpressionStatement & Opts;
+declare function isFile(node: Node | null | undefined): node is File;
+declare function isFile<Opts extends Options<File>>(node: Node | null | undefined, opts?: Opts | null): node is File & Opts;
+declare function isForInStatement(node: Node | null | undefined): node is ForInStatement;
+declare function isForInStatement<Opts extends Options<ForInStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ForInStatement & Opts;
+declare function isForStatement(node: Node | null | undefined): node is ForStatement;
+declare function isForStatement<Opts extends Options<ForStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ForStatement & Opts;
+declare function isFunctionDeclaration(node: Node | null | undefined): node is FunctionDeclaration;
+declare function isFunctionDeclaration<Opts extends Options<FunctionDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionDeclaration & Opts;
+declare function isFunctionExpression(node: Node | null | undefined): node is FunctionExpression;
+declare function isFunctionExpression<Opts extends Options<FunctionExpression>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionExpression & Opts;
+declare function isIdentifier(node: Node | null | undefined): node is Identifier;
+declare function isIdentifier<Opts extends Options<Identifier>>(node: Node | null | undefined, opts?: Opts | null): node is Identifier & Opts;
+declare function isIfStatement(node: Node | null | undefined): node is IfStatement;
+declare function isIfStatement<Opts extends Options<IfStatement>>(node: Node | null | undefined, opts?: Opts | null): node is IfStatement & Opts;
+declare function isLabeledStatement(node: Node | null | undefined): node is LabeledStatement;
+declare function isLabeledStatement<Opts extends Options<LabeledStatement>>(node: Node | null | undefined, opts?: Opts | null): node is LabeledStatement & Opts;
+declare function isStringLiteral(node: Node | null | undefined): node is StringLiteral;
+declare function isStringLiteral<Opts extends Options<StringLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is StringLiteral & Opts;
+declare function isNumericLiteral(node: Node | null | undefined): node is NumericLiteral;
+declare function isNumericLiteral<Opts extends Options<NumericLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is NumericLiteral & Opts;
+declare function isNullLiteral(node: Node | null | undefined): node is NullLiteral;
+declare function isNullLiteral<Opts extends Options<NullLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is NullLiteral & Opts;
+declare function isBooleanLiteral(node: Node | null | undefined): node is BooleanLiteral;
+declare function isBooleanLiteral<Opts extends Options<BooleanLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is BooleanLiteral & Opts;
+declare function isRegExpLiteral(node: Node | null | undefined): node is RegExpLiteral;
+declare function isRegExpLiteral<Opts extends Options<RegExpLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is RegExpLiteral & Opts;
+declare function isLogicalExpression(node: Node | null | undefined): node is LogicalExpression;
+declare function isLogicalExpression<Opts extends Options<LogicalExpression>>(node: Node | null | undefined, opts?: Opts | null): node is LogicalExpression & Opts;
+declare function isMemberExpression(node: Node | null | undefined): node is MemberExpression;
+declare function isMemberExpression<Opts extends Options<MemberExpression>>(node: Node | null | undefined, opts?: Opts | null): node is MemberExpression & Opts;
+declare function isNewExpression(node: Node | null | undefined): node is NewExpression;
+declare function isNewExpression<Opts extends Options<NewExpression>>(node: Node | null | undefined, opts?: Opts | null): node is NewExpression & Opts;
+declare function isProgram(node: Node | null | undefined): node is Program;
+declare function isProgram<Opts extends Options<Program>>(node: Node | null | undefined, opts?: Opts | null): node is Program & Opts;
+declare function isObjectExpression(node: Node | null | undefined): node is ObjectExpression;
+declare function isObjectExpression<Opts extends Options<ObjectExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectExpression & Opts;
+declare function isObjectMethod(node: Node | null | undefined): node is ObjectMethod;
+declare function isObjectMethod<Opts extends Options<ObjectMethod>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectMethod & Opts;
+declare function isObjectProperty(node: Node | null | undefined): node is ObjectProperty;
+declare function isObjectProperty<Opts extends Options<ObjectProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectProperty & Opts;
+declare function isRestElement(node: Node | null | undefined): node is RestElement;
+declare function isRestElement<Opts extends Options<RestElement>>(node: Node | null | undefined, opts?: Opts | null): node is RestElement & Opts;
+declare function isReturnStatement(node: Node | null | undefined): node is ReturnStatement;
+declare function isReturnStatement<Opts extends Options<ReturnStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ReturnStatement & Opts;
+declare function isSequenceExpression(node: Node | null | undefined): node is SequenceExpression;
+declare function isSequenceExpression<Opts extends Options<SequenceExpression>>(node: Node | null | undefined, opts?: Opts | null): node is SequenceExpression & Opts;
+declare function isParenthesizedExpression(node: Node | null | undefined): node is ParenthesizedExpression;
+declare function isParenthesizedExpression<Opts extends Options<ParenthesizedExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ParenthesizedExpression & Opts;
+declare function isSwitchCase(node: Node | null | undefined): node is SwitchCase;
+declare function isSwitchCase<Opts extends Options<SwitchCase>>(node: Node | null | undefined, opts?: Opts | null): node is SwitchCase & Opts;
+declare function isSwitchStatement(node: Node | null | undefined): node is SwitchStatement;
+declare function isSwitchStatement<Opts extends Options<SwitchStatement>>(node: Node | null | undefined, opts?: Opts | null): node is SwitchStatement & Opts;
+declare function isThisExpression(node: Node | null | undefined): node is ThisExpression;
+declare function isThisExpression<Opts extends Options<ThisExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ThisExpression & Opts;
+declare function isThrowStatement(node: Node | null | undefined): node is ThrowStatement;
+declare function isThrowStatement<Opts extends Options<ThrowStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ThrowStatement & Opts;
+declare function isTryStatement(node: Node | null | undefined): node is TryStatement;
+declare function isTryStatement<Opts extends Options<TryStatement>>(node: Node | null | undefined, opts?: Opts | null): node is TryStatement & Opts;
+declare function isUnaryExpression(node: Node | null | undefined): node is UnaryExpression;
+declare function isUnaryExpression<Opts extends Options<UnaryExpression>>(node: Node | null | undefined, opts?: Opts | null): node is UnaryExpression & Opts;
+declare function isUpdateExpression(node: Node | null | undefined): node is UpdateExpression;
+declare function isUpdateExpression<Opts extends Options<UpdateExpression>>(node: Node | null | undefined, opts?: Opts | null): node is UpdateExpression & Opts;
+declare function isVariableDeclaration(node: Node | null | undefined): node is VariableDeclaration;
+declare function isVariableDeclaration<Opts extends Options<VariableDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is VariableDeclaration & Opts;
+declare function isVariableDeclarator(node: Node | null | undefined): node is VariableDeclarator;
+declare function isVariableDeclarator<Opts extends Options<VariableDeclarator>>(node: Node | null | undefined, opts?: Opts | null): node is VariableDeclarator & Opts;
+declare function isWhileStatement(node: Node | null | undefined): node is WhileStatement;
+declare function isWhileStatement<Opts extends Options<WhileStatement>>(node: Node | null | undefined, opts?: Opts | null): node is WhileStatement & Opts;
+declare function isWithStatement(node: Node | null | undefined): node is WithStatement;
+declare function isWithStatement<Opts extends Options<WithStatement>>(node: Node | null | undefined, opts?: Opts | null): node is WithStatement & Opts;
+declare function isAssignmentPattern(node: Node | null | undefined): node is AssignmentPattern;
+declare function isAssignmentPattern<Opts extends Options<AssignmentPattern>>(node: Node | null | undefined, opts?: Opts | null): node is AssignmentPattern & Opts;
+declare function isArrayPattern(node: Node | null | undefined): node is ArrayPattern;
+declare function isArrayPattern<Opts extends Options<ArrayPattern>>(node: Node | null | undefined, opts?: Opts | null): node is ArrayPattern & Opts;
+declare function isArrowFunctionExpression(node: Node | null | undefined): node is ArrowFunctionExpression;
+declare function isArrowFunctionExpression<Opts extends Options<ArrowFunctionExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ArrowFunctionExpression & Opts;
+declare function isClassBody(node: Node | null | undefined): node is ClassBody;
+declare function isClassBody<Opts extends Options<ClassBody>>(node: Node | null | undefined, opts?: Opts | null): node is ClassBody & Opts;
+declare function isClassExpression(node: Node | null | undefined): node is ClassExpression;
+declare function isClassExpression<Opts extends Options<ClassExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ClassExpression & Opts;
+declare function isClassDeclaration(node: Node | null | undefined): node is ClassDeclaration;
+declare function isClassDeclaration<Opts extends Options<ClassDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ClassDeclaration & Opts;
+declare function isExportAllDeclaration(node: Node | null | undefined): node is ExportAllDeclaration;
+declare function isExportAllDeclaration<Opts extends Options<ExportAllDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ExportAllDeclaration & Opts;
+declare function isExportDefaultDeclaration(node: Node | null | undefined): node is ExportDefaultDeclaration;
+declare function isExportDefaultDeclaration<Opts extends Options<ExportDefaultDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ExportDefaultDeclaration & Opts;
+declare function isExportNamedDeclaration(node: Node | null | undefined): node is ExportNamedDeclaration;
+declare function isExportNamedDeclaration<Opts extends Options<ExportNamedDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ExportNamedDeclaration & Opts;
+declare function isExportSpecifier(node: Node | null | undefined): node is ExportSpecifier;
+declare function isExportSpecifier<Opts extends Options<ExportSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ExportSpecifier & Opts;
+declare function isForOfStatement(node: Node | null | undefined): node is ForOfStatement;
+declare function isForOfStatement<Opts extends Options<ForOfStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ForOfStatement & Opts;
+declare function isImportDeclaration(node: Node | null | undefined): node is ImportDeclaration;
+declare function isImportDeclaration<Opts extends Options<ImportDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ImportDeclaration & Opts;
+declare function isImportDefaultSpecifier(node: Node | null | undefined): node is ImportDefaultSpecifier;
+declare function isImportDefaultSpecifier<Opts extends Options<ImportDefaultSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ImportDefaultSpecifier & Opts;
+declare function isImportNamespaceSpecifier(node: Node | null | undefined): node is ImportNamespaceSpecifier;
+declare function isImportNamespaceSpecifier<Opts extends Options<ImportNamespaceSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ImportNamespaceSpecifier & Opts;
+declare function isImportSpecifier(node: Node | null | undefined): node is ImportSpecifier;
+declare function isImportSpecifier<Opts extends Options<ImportSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ImportSpecifier & Opts;
+declare function isImportExpression(node: Node | null | undefined): node is ImportExpression;
+declare function isImportExpression<Opts extends Options<ImportExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ImportExpression & Opts;
+declare function isMetaProperty(node: Node | null | undefined): node is MetaProperty;
+declare function isMetaProperty<Opts extends Options<MetaProperty>>(node: Node | null | undefined, opts?: Opts | null): node is MetaProperty & Opts;
+declare function isClassMethod(node: Node | null | undefined): node is ClassMethod;
+declare function isClassMethod<Opts extends Options<ClassMethod>>(node: Node | null | undefined, opts?: Opts | null): node is ClassMethod & Opts;
+declare function isObjectPattern(node: Node | null | undefined): node is ObjectPattern;
+declare function isObjectPattern<Opts extends Options<ObjectPattern>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectPattern & Opts;
+declare function isSpreadElement(node: Node | null | undefined): node is SpreadElement;
+declare function isSpreadElement<Opts extends Options<SpreadElement>>(node: Node | null | undefined, opts?: Opts | null): node is SpreadElement & Opts;
+declare function isSuper(node: Node | null | undefined): node is Super;
+declare function isSuper<Opts extends Options<Super>>(node: Node | null | undefined, opts?: Opts | null): node is Super & Opts;
+declare function isTaggedTemplateExpression(node: Node | null | undefined): node is TaggedTemplateExpression;
+declare function isTaggedTemplateExpression<Opts extends Options<TaggedTemplateExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TaggedTemplateExpression & Opts;
+declare function isTemplateElement(node: Node | null | undefined): node is TemplateElement;
+declare function isTemplateElement<Opts extends Options<TemplateElement>>(node: Node | null | undefined, opts?: Opts | null): node is TemplateElement & Opts;
+declare function isTemplateLiteral(node: Node | null | undefined): node is TemplateLiteral;
+declare function isTemplateLiteral<Opts extends Options<TemplateLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is TemplateLiteral & Opts;
+declare function isYieldExpression(node: Node | null | undefined): node is YieldExpression;
+declare function isYieldExpression<Opts extends Options<YieldExpression>>(node: Node | null | undefined, opts?: Opts | null): node is YieldExpression & Opts;
+declare function isAwaitExpression(node: Node | null | undefined): node is AwaitExpression;
+declare function isAwaitExpression<Opts extends Options<AwaitExpression>>(node: Node | null | undefined, opts?: Opts | null): node is AwaitExpression & Opts;
+declare function isImport(node: Node | null | undefined): node is Import;
+declare function isImport<Opts extends Options<Import>>(node: Node | null | undefined, opts?: Opts | null): node is Import & Opts;
+declare function isBigIntLiteral(node: Node | null | undefined): node is BigIntLiteral;
+declare function isBigIntLiteral<Opts extends Options<BigIntLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is BigIntLiteral & Opts;
+declare function isExportNamespaceSpecifier(node: Node | null | undefined): node is ExportNamespaceSpecifier;
+declare function isExportNamespaceSpecifier<Opts extends Options<ExportNamespaceSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ExportNamespaceSpecifier & Opts;
+declare function isOptionalMemberExpression(node: Node | null | undefined): node is OptionalMemberExpression;
+declare function isOptionalMemberExpression<Opts extends Options<OptionalMemberExpression>>(node: Node | null | undefined, opts?: Opts | null): node is OptionalMemberExpression & Opts;
+declare function isOptionalCallExpression(node: Node | null | undefined): node is OptionalCallExpression;
+declare function isOptionalCallExpression<Opts extends Options<OptionalCallExpression>>(node: Node | null | undefined, opts?: Opts | null): node is OptionalCallExpression & Opts;
+declare function isClassProperty(node: Node | null | undefined): node is ClassProperty;
+declare function isClassProperty<Opts extends Options<ClassProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ClassProperty & Opts;
+declare function isClassAccessorProperty(node: Node | null | undefined): node is ClassAccessorProperty;
+declare function isClassAccessorProperty<Opts extends Options<ClassAccessorProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ClassAccessorProperty & Opts;
+declare function isClassPrivateProperty(node: Node | null | undefined): node is ClassPrivateProperty;
+declare function isClassPrivateProperty<Opts extends Options<ClassPrivateProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ClassPrivateProperty & Opts;
+declare function isClassPrivateMethod(node: Node | null | undefined): node is ClassPrivateMethod;
+declare function isClassPrivateMethod<Opts extends Options<ClassPrivateMethod>>(node: Node | null | undefined, opts?: Opts | null): node is ClassPrivateMethod & Opts;
+declare function isPrivateName(node: Node | null | undefined): node is PrivateName;
+declare function isPrivateName<Opts extends Options<PrivateName>>(node: Node | null | undefined, opts?: Opts | null): node is PrivateName & Opts;
+declare function isStaticBlock(node: Node | null | undefined): node is StaticBlock;
+declare function isStaticBlock<Opts extends Options<StaticBlock>>(node: Node | null | undefined, opts?: Opts | null): node is StaticBlock & Opts;
+declare function isImportAttribute(node: Node | null | undefined): node is ImportAttribute;
+declare function isImportAttribute<Opts extends Options<ImportAttribute>>(node: Node | null | undefined, opts?: Opts | null): node is ImportAttribute & Opts;
+declare function isAnyTypeAnnotation(node: Node | null | undefined): node is AnyTypeAnnotation;
+declare function isAnyTypeAnnotation<Opts extends Options<AnyTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is AnyTypeAnnotation & Opts;
+declare function isArrayTypeAnnotation(node: Node | null | undefined): node is ArrayTypeAnnotation;
+declare function isArrayTypeAnnotation<Opts extends Options<ArrayTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is ArrayTypeAnnotation & Opts;
+declare function isBooleanTypeAnnotation(node: Node | null | undefined): node is BooleanTypeAnnotation;
+declare function isBooleanTypeAnnotation<Opts extends Options<BooleanTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is BooleanTypeAnnotation & Opts;
+declare function isBooleanLiteralTypeAnnotation(node: Node | null | undefined): node is BooleanLiteralTypeAnnotation;
+declare function isBooleanLiteralTypeAnnotation<Opts extends Options<BooleanLiteralTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is BooleanLiteralTypeAnnotation & Opts;
+declare function isNullLiteralTypeAnnotation(node: Node | null | undefined): node is NullLiteralTypeAnnotation;
+declare function isNullLiteralTypeAnnotation<Opts extends Options<NullLiteralTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is NullLiteralTypeAnnotation & Opts;
+declare function isClassImplements(node: Node | null | undefined): node is ClassImplements;
+declare function isClassImplements<Opts extends Options<ClassImplements>>(node: Node | null | undefined, opts?: Opts | null): node is ClassImplements & Opts;
+declare function isDeclareClass(node: Node | null | undefined): node is DeclareClass;
+declare function isDeclareClass<Opts extends Options<DeclareClass>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareClass & Opts;
+declare function isDeclareFunction(node: Node | null | undefined): node is DeclareFunction;
+declare function isDeclareFunction<Opts extends Options<DeclareFunction>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareFunction & Opts;
+declare function isDeclareInterface(node: Node | null | undefined): node is DeclareInterface;
+declare function isDeclareInterface<Opts extends Options<DeclareInterface>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareInterface & Opts;
+declare function isDeclareModule(node: Node | null | undefined): node is DeclareModule;
+declare function isDeclareModule<Opts extends Options<DeclareModule>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareModule & Opts;
+declare function isDeclareModuleExports(node: Node | null | undefined): node is DeclareModuleExports;
+declare function isDeclareModuleExports<Opts extends Options<DeclareModuleExports>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareModuleExports & Opts;
+declare function isDeclareTypeAlias(node: Node | null | undefined): node is DeclareTypeAlias;
+declare function isDeclareTypeAlias<Opts extends Options<DeclareTypeAlias>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareTypeAlias & Opts;
+declare function isDeclareOpaqueType(node: Node | null | undefined): node is DeclareOpaqueType;
+declare function isDeclareOpaqueType<Opts extends Options<DeclareOpaqueType>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareOpaqueType & Opts;
+declare function isDeclareVariable(node: Node | null | undefined): node is DeclareVariable;
+declare function isDeclareVariable<Opts extends Options<DeclareVariable>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareVariable & Opts;
+declare function isDeclareExportDeclaration(node: Node | null | undefined): node is DeclareExportDeclaration;
+declare function isDeclareExportDeclaration<Opts extends Options<DeclareExportDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareExportDeclaration & Opts;
+declare function isDeclareExportAllDeclaration(node: Node | null | undefined): node is DeclareExportAllDeclaration;
+declare function isDeclareExportAllDeclaration<Opts extends Options<DeclareExportAllDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is DeclareExportAllDeclaration & Opts;
+declare function isDeclaredPredicate(node: Node | null | undefined): node is DeclaredPredicate;
+declare function isDeclaredPredicate<Opts extends Options<DeclaredPredicate>>(node: Node | null | undefined, opts?: Opts | null): node is DeclaredPredicate & Opts;
+declare function isExistsTypeAnnotation(node: Node | null | undefined): node is ExistsTypeAnnotation;
+declare function isExistsTypeAnnotation<Opts extends Options<ExistsTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is ExistsTypeAnnotation & Opts;
+declare function isFunctionTypeAnnotation(node: Node | null | undefined): node is FunctionTypeAnnotation;
+declare function isFunctionTypeAnnotation<Opts extends Options<FunctionTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionTypeAnnotation & Opts;
+declare function isFunctionTypeParam(node: Node | null | undefined): node is FunctionTypeParam;
+declare function isFunctionTypeParam<Opts extends Options<FunctionTypeParam>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionTypeParam & Opts;
+declare function isGenericTypeAnnotation(node: Node | null | undefined): node is GenericTypeAnnotation;
+declare function isGenericTypeAnnotation<Opts extends Options<GenericTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is GenericTypeAnnotation & Opts;
+declare function isInferredPredicate(node: Node | null | undefined): node is InferredPredicate;
+declare function isInferredPredicate<Opts extends Options<InferredPredicate>>(node: Node | null | undefined, opts?: Opts | null): node is InferredPredicate & Opts;
+declare function isInterfaceExtends(node: Node | null | undefined): node is InterfaceExtends;
+declare function isInterfaceExtends<Opts extends Options<InterfaceExtends>>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceExtends & Opts;
+declare function isInterfaceDeclaration(node: Node | null | undefined): node is InterfaceDeclaration;
+declare function isInterfaceDeclaration<Opts extends Options<InterfaceDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceDeclaration & Opts;
+declare function isInterfaceTypeAnnotation(node: Node | null | undefined): node is InterfaceTypeAnnotation;
+declare function isInterfaceTypeAnnotation<Opts extends Options<InterfaceTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is InterfaceTypeAnnotation & Opts;
+declare function isIntersectionTypeAnnotation(node: Node | null | undefined): node is IntersectionTypeAnnotation;
+declare function isIntersectionTypeAnnotation<Opts extends Options<IntersectionTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is IntersectionTypeAnnotation & Opts;
+declare function isMixedTypeAnnotation(node: Node | null | undefined): node is MixedTypeAnnotation;
+declare function isMixedTypeAnnotation<Opts extends Options<MixedTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is MixedTypeAnnotation & Opts;
+declare function isEmptyTypeAnnotation(node: Node | null | undefined): node is EmptyTypeAnnotation;
+declare function isEmptyTypeAnnotation<Opts extends Options<EmptyTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is EmptyTypeAnnotation & Opts;
+declare function isNullableTypeAnnotation(node: Node | null | undefined): node is NullableTypeAnnotation;
+declare function isNullableTypeAnnotation<Opts extends Options<NullableTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is NullableTypeAnnotation & Opts;
+declare function isNumberLiteralTypeAnnotation(node: Node | null | undefined): node is NumberLiteralTypeAnnotation;
+declare function isNumberLiteralTypeAnnotation<Opts extends Options<NumberLiteralTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is NumberLiteralTypeAnnotation & Opts;
+declare function isNumberTypeAnnotation(node: Node | null | undefined): node is NumberTypeAnnotation;
+declare function isNumberTypeAnnotation<Opts extends Options<NumberTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is NumberTypeAnnotation & Opts;
+declare function isObjectTypeAnnotation(node: Node | null | undefined): node is ObjectTypeAnnotation;
+declare function isObjectTypeAnnotation<Opts extends Options<ObjectTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeAnnotation & Opts;
+declare function isObjectTypeInternalSlot(node: Node | null | undefined): node is ObjectTypeInternalSlot;
+declare function isObjectTypeInternalSlot<Opts extends Options<ObjectTypeInternalSlot>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeInternalSlot & Opts;
+declare function isObjectTypeCallProperty(node: Node | null | undefined): node is ObjectTypeCallProperty;
+declare function isObjectTypeCallProperty<Opts extends Options<ObjectTypeCallProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeCallProperty & Opts;
+declare function isObjectTypeIndexer(node: Node | null | undefined): node is ObjectTypeIndexer;
+declare function isObjectTypeIndexer<Opts extends Options<ObjectTypeIndexer>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeIndexer & Opts;
+declare function isObjectTypeProperty(node: Node | null | undefined): node is ObjectTypeProperty;
+declare function isObjectTypeProperty<Opts extends Options<ObjectTypeProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeProperty & Opts;
+declare function isObjectTypeSpreadProperty(node: Node | null | undefined): node is ObjectTypeSpreadProperty;
+declare function isObjectTypeSpreadProperty<Opts extends Options<ObjectTypeSpreadProperty>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectTypeSpreadProperty & Opts;
+declare function isOpaqueType(node: Node | null | undefined): node is OpaqueType;
+declare function isOpaqueType<Opts extends Options<OpaqueType>>(node: Node | null | undefined, opts?: Opts | null): node is OpaqueType & Opts;
+declare function isQualifiedTypeIdentifier(node: Node | null | undefined): node is QualifiedTypeIdentifier;
+declare function isQualifiedTypeIdentifier<Opts extends Options<QualifiedTypeIdentifier>>(node: Node | null | undefined, opts?: Opts | null): node is QualifiedTypeIdentifier & Opts;
+declare function isStringLiteralTypeAnnotation(node: Node | null | undefined): node is StringLiteralTypeAnnotation;
+declare function isStringLiteralTypeAnnotation<Opts extends Options<StringLiteralTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is StringLiteralTypeAnnotation & Opts;
+declare function isStringTypeAnnotation(node: Node | null | undefined): node is StringTypeAnnotation;
+declare function isStringTypeAnnotation<Opts extends Options<StringTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is StringTypeAnnotation & Opts;
+declare function isSymbolTypeAnnotation(node: Node | null | undefined): node is SymbolTypeAnnotation;
+declare function isSymbolTypeAnnotation<Opts extends Options<SymbolTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is SymbolTypeAnnotation & Opts;
+declare function isThisTypeAnnotation(node: Node | null | undefined): node is ThisTypeAnnotation;
+declare function isThisTypeAnnotation<Opts extends Options<ThisTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is ThisTypeAnnotation & Opts;
+declare function isTupleTypeAnnotation(node: Node | null | undefined): node is TupleTypeAnnotation;
+declare function isTupleTypeAnnotation<Opts extends Options<TupleTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is TupleTypeAnnotation & Opts;
+declare function isTypeofTypeAnnotation(node: Node | null | undefined): node is TypeofTypeAnnotation;
+declare function isTypeofTypeAnnotation<Opts extends Options<TypeofTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is TypeofTypeAnnotation & Opts;
+declare function isTypeAlias(node: Node | null | undefined): node is TypeAlias;
+declare function isTypeAlias<Opts extends Options<TypeAlias>>(node: Node | null | undefined, opts?: Opts | null): node is TypeAlias & Opts;
+declare function isTypeAnnotation(node: Node | null | undefined): node is TypeAnnotation;
+declare function isTypeAnnotation<Opts extends Options<TypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is TypeAnnotation & Opts;
+declare function isTypeCastExpression(node: Node | null | undefined): node is TypeCastExpression;
+declare function isTypeCastExpression<Opts extends Options<TypeCastExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TypeCastExpression & Opts;
+declare function isTypeParameter(node: Node | null | undefined): node is TypeParameter;
+declare function isTypeParameter<Opts extends Options<TypeParameter>>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameter & Opts;
+declare function isTypeParameterDeclaration(node: Node | null | undefined): node is TypeParameterDeclaration;
+declare function isTypeParameterDeclaration<Opts extends Options<TypeParameterDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameterDeclaration & Opts;
+declare function isTypeParameterInstantiation(node: Node | null | undefined): node is TypeParameterInstantiation;
+declare function isTypeParameterInstantiation<Opts extends Options<TypeParameterInstantiation>>(node: Node | null | undefined, opts?: Opts | null): node is TypeParameterInstantiation & Opts;
+declare function isUnionTypeAnnotation(node: Node | null | undefined): node is UnionTypeAnnotation;
+declare function isUnionTypeAnnotation<Opts extends Options<UnionTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is UnionTypeAnnotation & Opts;
+declare function isVariance(node: Node | null | undefined): node is Variance;
+declare function isVariance<Opts extends Options<Variance>>(node: Node | null | undefined, opts?: Opts | null): node is Variance & Opts;
+declare function isVoidTypeAnnotation(node: Node | null | undefined): node is VoidTypeAnnotation;
+declare function isVoidTypeAnnotation<Opts extends Options<VoidTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is VoidTypeAnnotation & Opts;
+declare function isEnumDeclaration(node: Node | null | undefined): node is EnumDeclaration;
+declare function isEnumDeclaration<Opts extends Options<EnumDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is EnumDeclaration & Opts;
+declare function isEnumBooleanBody(node: Node | null | undefined): node is EnumBooleanBody;
+declare function isEnumBooleanBody<Opts extends Options<EnumBooleanBody>>(node: Node | null | undefined, opts?: Opts | null): node is EnumBooleanBody & Opts;
+declare function isEnumNumberBody(node: Node | null | undefined): node is EnumNumberBody;
+declare function isEnumNumberBody<Opts extends Options<EnumNumberBody>>(node: Node | null | undefined, opts?: Opts | null): node is EnumNumberBody & Opts;
+declare function isEnumStringBody(node: Node | null | undefined): node is EnumStringBody;
+declare function isEnumStringBody<Opts extends Options<EnumStringBody>>(node: Node | null | undefined, opts?: Opts | null): node is EnumStringBody & Opts;
+declare function isEnumSymbolBody(node: Node | null | undefined): node is EnumSymbolBody;
+declare function isEnumSymbolBody<Opts extends Options<EnumSymbolBody>>(node: Node | null | undefined, opts?: Opts | null): node is EnumSymbolBody & Opts;
+declare function isEnumBooleanMember(node: Node | null | undefined): node is EnumBooleanMember;
+declare function isEnumBooleanMember<Opts extends Options<EnumBooleanMember>>(node: Node | null | undefined, opts?: Opts | null): node is EnumBooleanMember & Opts;
+declare function isEnumNumberMember(node: Node | null | undefined): node is EnumNumberMember;
+declare function isEnumNumberMember<Opts extends Options<EnumNumberMember>>(node: Node | null | undefined, opts?: Opts | null): node is EnumNumberMember & Opts;
+declare function isEnumStringMember(node: Node | null | undefined): node is EnumStringMember;
+declare function isEnumStringMember<Opts extends Options<EnumStringMember>>(node: Node | null | undefined, opts?: Opts | null): node is EnumStringMember & Opts;
+declare function isEnumDefaultedMember(node: Node | null | undefined): node is EnumDefaultedMember;
+declare function isEnumDefaultedMember<Opts extends Options<EnumDefaultedMember>>(node: Node | null | undefined, opts?: Opts | null): node is EnumDefaultedMember & Opts;
+declare function isIndexedAccessType(node: Node | null | undefined): node is IndexedAccessType;
+declare function isIndexedAccessType<Opts extends Options<IndexedAccessType>>(node: Node | null | undefined, opts?: Opts | null): node is IndexedAccessType & Opts;
+declare function isOptionalIndexedAccessType(node: Node | null | undefined): node is OptionalIndexedAccessType;
+declare function isOptionalIndexedAccessType<Opts extends Options<OptionalIndexedAccessType>>(node: Node | null | undefined, opts?: Opts | null): node is OptionalIndexedAccessType & Opts;
+declare function isJSXAttribute(node: Node | null | undefined): node is JSXAttribute;
+declare function isJSXAttribute<Opts extends Options<JSXAttribute>>(node: Node | null | undefined, opts?: Opts | null): node is JSXAttribute & Opts;
+declare function isJSXClosingElement(node: Node | null | undefined): node is JSXClosingElement;
+declare function isJSXClosingElement<Opts extends Options<JSXClosingElement>>(node: Node | null | undefined, opts?: Opts | null): node is JSXClosingElement & Opts;
+declare function isJSXElement(node: Node | null | undefined): node is JSXElement;
+declare function isJSXElement<Opts extends Options<JSXElement>>(node: Node | null | undefined, opts?: Opts | null): node is JSXElement & Opts;
+declare function isJSXEmptyExpression(node: Node | null | undefined): node is JSXEmptyExpression;
+declare function isJSXEmptyExpression<Opts extends Options<JSXEmptyExpression>>(node: Node | null | undefined, opts?: Opts | null): node is JSXEmptyExpression & Opts;
+declare function isJSXExpressionContainer(node: Node | null | undefined): node is JSXExpressionContainer;
+declare function isJSXExpressionContainer<Opts extends Options<JSXExpressionContainer>>(node: Node | null | undefined, opts?: Opts | null): node is JSXExpressionContainer & Opts;
+declare function isJSXSpreadChild(node: Node | null | undefined): node is JSXSpreadChild;
+declare function isJSXSpreadChild<Opts extends Options<JSXSpreadChild>>(node: Node | null | undefined, opts?: Opts | null): node is JSXSpreadChild & Opts;
+declare function isJSXIdentifier(node: Node | null | undefined): node is JSXIdentifier;
+declare function isJSXIdentifier<Opts extends Options<JSXIdentifier>>(node: Node | null | undefined, opts?: Opts | null): node is JSXIdentifier & Opts;
+declare function isJSXMemberExpression(node: Node | null | undefined): node is JSXMemberExpression;
+declare function isJSXMemberExpression<Opts extends Options<JSXMemberExpression>>(node: Node | null | undefined, opts?: Opts | null): node is JSXMemberExpression & Opts;
+declare function isJSXNamespacedName(node: Node | null | undefined): node is JSXNamespacedName;
+declare function isJSXNamespacedName<Opts extends Options<JSXNamespacedName>>(node: Node | null | undefined, opts?: Opts | null): node is JSXNamespacedName & Opts;
+declare function isJSXOpeningElement(node: Node | null | undefined): node is JSXOpeningElement;
+declare function isJSXOpeningElement<Opts extends Options<JSXOpeningElement>>(node: Node | null | undefined, opts?: Opts | null): node is JSXOpeningElement & Opts;
+declare function isJSXSpreadAttribute(node: Node | null | undefined): node is JSXSpreadAttribute;
+declare function isJSXSpreadAttribute<Opts extends Options<JSXSpreadAttribute>>(node: Node | null | undefined, opts?: Opts | null): node is JSXSpreadAttribute & Opts;
+declare function isJSXText(node: Node | null | undefined): node is JSXText;
+declare function isJSXText<Opts extends Options<JSXText>>(node: Node | null | undefined, opts?: Opts | null): node is JSXText & Opts;
+declare function isJSXFragment(node: Node | null | undefined): node is JSXFragment;
+declare function isJSXFragment<Opts extends Options<JSXFragment>>(node: Node | null | undefined, opts?: Opts | null): node is JSXFragment & Opts;
+declare function isJSXOpeningFragment(node: Node | null | undefined): node is JSXOpeningFragment;
+declare function isJSXOpeningFragment<Opts extends Options<JSXOpeningFragment>>(node: Node | null | undefined, opts?: Opts | null): node is JSXOpeningFragment & Opts;
+declare function isJSXClosingFragment(node: Node | null | undefined): node is JSXClosingFragment;
+declare function isJSXClosingFragment<Opts extends Options<JSXClosingFragment>>(node: Node | null | undefined, opts?: Opts | null): node is JSXClosingFragment & Opts;
+declare function isNoop(node: Node | null | undefined): node is Noop;
+declare function isNoop<Opts extends Options<Noop>>(node: Node | null | undefined, opts?: Opts | null): node is Noop & Opts;
+declare function isPlaceholder(node: Node | null | undefined): node is Placeholder;
+declare function isPlaceholder<Opts extends Options<Placeholder>>(node: Node | null | undefined, opts?: Opts | null): node is Placeholder & Opts;
+declare function isV8IntrinsicIdentifier(node: Node | null | undefined): node is V8IntrinsicIdentifier;
+declare function isV8IntrinsicIdentifier<Opts extends Options<V8IntrinsicIdentifier>>(node: Node | null | undefined, opts?: Opts | null): node is V8IntrinsicIdentifier & Opts;
+declare function isArgumentPlaceholder(node: Node | null | undefined): node is ArgumentPlaceholder;
+declare function isArgumentPlaceholder<Opts extends Options<ArgumentPlaceholder>>(node: Node | null | undefined, opts?: Opts | null): node is ArgumentPlaceholder & Opts;
+declare function isBindExpression(node: Node | null | undefined): node is BindExpression;
+declare function isBindExpression<Opts extends Options<BindExpression>>(node: Node | null | undefined, opts?: Opts | null): node is BindExpression & Opts;
+declare function isDecorator(node: Node | null | undefined): node is Decorator;
+declare function isDecorator<Opts extends Options<Decorator>>(node: Node | null | undefined, opts?: Opts | null): node is Decorator & Opts;
+declare function isDoExpression(node: Node | null | undefined): node is DoExpression;
+declare function isDoExpression<Opts extends Options<DoExpression>>(node: Node | null | undefined, opts?: Opts | null): node is DoExpression & Opts;
+declare function isExportDefaultSpecifier(node: Node | null | undefined): node is ExportDefaultSpecifier;
+declare function isExportDefaultSpecifier<Opts extends Options<ExportDefaultSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ExportDefaultSpecifier & Opts;
+declare function isRecordExpression(node: Node | null | undefined): node is RecordExpression;
+declare function isRecordExpression<Opts extends Options<RecordExpression>>(node: Node | null | undefined, opts?: Opts | null): node is RecordExpression & Opts;
+declare function isTupleExpression(node: Node | null | undefined): node is TupleExpression;
+declare function isTupleExpression<Opts extends Options<TupleExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TupleExpression & Opts;
+declare function isDecimalLiteral(node: Node | null | undefined): node is DecimalLiteral;
+declare function isDecimalLiteral<Opts extends Options<DecimalLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is DecimalLiteral & Opts;
+declare function isModuleExpression(node: Node | null | undefined): node is ModuleExpression;
+declare function isModuleExpression<Opts extends Options<ModuleExpression>>(node: Node | null | undefined, opts?: Opts | null): node is ModuleExpression & Opts;
+declare function isTopicReference(node: Node | null | undefined): node is TopicReference;
+declare function isTopicReference<Opts extends Options<TopicReference>>(node: Node | null | undefined, opts?: Opts | null): node is TopicReference & Opts;
+declare function isPipelineTopicExpression(node: Node | null | undefined): node is PipelineTopicExpression;
+declare function isPipelineTopicExpression<Opts extends Options<PipelineTopicExpression>>(node: Node | null | undefined, opts?: Opts | null): node is PipelineTopicExpression & Opts;
+declare function isPipelineBareFunction(node: Node | null | undefined): node is PipelineBareFunction;
+declare function isPipelineBareFunction<Opts extends Options<PipelineBareFunction>>(node: Node | null | undefined, opts?: Opts | null): node is PipelineBareFunction & Opts;
+declare function isPipelinePrimaryTopicReference(node: Node | null | undefined): node is PipelinePrimaryTopicReference;
+declare function isPipelinePrimaryTopicReference<Opts extends Options<PipelinePrimaryTopicReference>>(node: Node | null | undefined, opts?: Opts | null): node is PipelinePrimaryTopicReference & Opts;
+declare function isVoidPattern(node: Node | null | undefined): node is VoidPattern;
+declare function isVoidPattern<Opts extends Options<VoidPattern>>(node: Node | null | undefined, opts?: Opts | null): node is VoidPattern & Opts;
+declare function isTSParameterProperty(node: Node | null | undefined): node is TSParameterProperty;
+declare function isTSParameterProperty<Opts extends Options<TSParameterProperty>>(node: Node | null | undefined, opts?: Opts | null): node is TSParameterProperty & Opts;
+declare function isTSDeclareFunction(node: Node | null | undefined): node is TSDeclareFunction;
+declare function isTSDeclareFunction<Opts extends Options<TSDeclareFunction>>(node: Node | null | undefined, opts?: Opts | null): node is TSDeclareFunction & Opts;
+declare function isTSDeclareMethod(node: Node | null | undefined): node is TSDeclareMethod;
+declare function isTSDeclareMethod<Opts extends Options<TSDeclareMethod>>(node: Node | null | undefined, opts?: Opts | null): node is TSDeclareMethod & Opts;
+declare function isTSQualifiedName(node: Node | null | undefined): node is TSQualifiedName;
+declare function isTSQualifiedName<Opts extends Options<TSQualifiedName>>(node: Node | null | undefined, opts?: Opts | null): node is TSQualifiedName & Opts;
+declare function isTSCallSignatureDeclaration(node: Node | null | undefined): node is TSCallSignatureDeclaration;
+declare function isTSCallSignatureDeclaration<Opts extends Options<TSCallSignatureDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSCallSignatureDeclaration & Opts;
+declare function isTSConstructSignatureDeclaration(node: Node | null | undefined): node is TSConstructSignatureDeclaration;
+declare function isTSConstructSignatureDeclaration<Opts extends Options<TSConstructSignatureDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSConstructSignatureDeclaration & Opts;
+declare function isTSPropertySignature(node: Node | null | undefined): node is TSPropertySignature;
+declare function isTSPropertySignature<Opts extends Options<TSPropertySignature>>(node: Node | null | undefined, opts?: Opts | null): node is TSPropertySignature & Opts;
+declare function isTSMethodSignature(node: Node | null | undefined): node is TSMethodSignature;
+declare function isTSMethodSignature<Opts extends Options<TSMethodSignature>>(node: Node | null | undefined, opts?: Opts | null): node is TSMethodSignature & Opts;
+declare function isTSIndexSignature(node: Node | null | undefined): node is TSIndexSignature;
+declare function isTSIndexSignature<Opts extends Options<TSIndexSignature>>(node: Node | null | undefined, opts?: Opts | null): node is TSIndexSignature & Opts;
+declare function isTSAnyKeyword(node: Node | null | undefined): node is TSAnyKeyword;
+declare function isTSAnyKeyword<Opts extends Options<TSAnyKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSAnyKeyword & Opts;
+declare function isTSBooleanKeyword(node: Node | null | undefined): node is TSBooleanKeyword;
+declare function isTSBooleanKeyword<Opts extends Options<TSBooleanKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSBooleanKeyword & Opts;
+declare function isTSBigIntKeyword(node: Node | null | undefined): node is TSBigIntKeyword;
+declare function isTSBigIntKeyword<Opts extends Options<TSBigIntKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSBigIntKeyword & Opts;
+declare function isTSIntrinsicKeyword(node: Node | null | undefined): node is TSIntrinsicKeyword;
+declare function isTSIntrinsicKeyword<Opts extends Options<TSIntrinsicKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSIntrinsicKeyword & Opts;
+declare function isTSNeverKeyword(node: Node | null | undefined): node is TSNeverKeyword;
+declare function isTSNeverKeyword<Opts extends Options<TSNeverKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSNeverKeyword & Opts;
+declare function isTSNullKeyword(node: Node | null | undefined): node is TSNullKeyword;
+declare function isTSNullKeyword<Opts extends Options<TSNullKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSNullKeyword & Opts;
+declare function isTSNumberKeyword(node: Node | null | undefined): node is TSNumberKeyword;
+declare function isTSNumberKeyword<Opts extends Options<TSNumberKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSNumberKeyword & Opts;
+declare function isTSObjectKeyword(node: Node | null | undefined): node is TSObjectKeyword;
+declare function isTSObjectKeyword<Opts extends Options<TSObjectKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSObjectKeyword & Opts;
+declare function isTSStringKeyword(node: Node | null | undefined): node is TSStringKeyword;
+declare function isTSStringKeyword<Opts extends Options<TSStringKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSStringKeyword & Opts;
+declare function isTSSymbolKeyword(node: Node | null | undefined): node is TSSymbolKeyword;
+declare function isTSSymbolKeyword<Opts extends Options<TSSymbolKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSSymbolKeyword & Opts;
+declare function isTSUndefinedKeyword(node: Node | null | undefined): node is TSUndefinedKeyword;
+declare function isTSUndefinedKeyword<Opts extends Options<TSUndefinedKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSUndefinedKeyword & Opts;
+declare function isTSUnknownKeyword(node: Node | null | undefined): node is TSUnknownKeyword;
+declare function isTSUnknownKeyword<Opts extends Options<TSUnknownKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSUnknownKeyword & Opts;
+declare function isTSVoidKeyword(node: Node | null | undefined): node is TSVoidKeyword;
+declare function isTSVoidKeyword<Opts extends Options<TSVoidKeyword>>(node: Node | null | undefined, opts?: Opts | null): node is TSVoidKeyword & Opts;
+declare function isTSThisType(node: Node | null | undefined): node is TSThisType;
+declare function isTSThisType<Opts extends Options<TSThisType>>(node: Node | null | undefined, opts?: Opts | null): node is TSThisType & Opts;
+declare function isTSFunctionType(node: Node | null | undefined): node is TSFunctionType;
+declare function isTSFunctionType<Opts extends Options<TSFunctionType>>(node: Node | null | undefined, opts?: Opts | null): node is TSFunctionType & Opts;
+declare function isTSConstructorType(node: Node | null | undefined): node is TSConstructorType;
+declare function isTSConstructorType<Opts extends Options<TSConstructorType>>(node: Node | null | undefined, opts?: Opts | null): node is TSConstructorType & Opts;
+declare function isTSTypeReference(node: Node | null | undefined): node is TSTypeReference;
+declare function isTSTypeReference<Opts extends Options<TSTypeReference>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeReference & Opts;
+declare function isTSTypePredicate(node: Node | null | undefined): node is TSTypePredicate;
+declare function isTSTypePredicate<Opts extends Options<TSTypePredicate>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypePredicate & Opts;
+declare function isTSTypeQuery(node: Node | null | undefined): node is TSTypeQuery;
+declare function isTSTypeQuery<Opts extends Options<TSTypeQuery>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeQuery & Opts;
+declare function isTSTypeLiteral(node: Node | null | undefined): node is TSTypeLiteral;
+declare function isTSTypeLiteral<Opts extends Options<TSTypeLiteral>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeLiteral & Opts;
+declare function isTSArrayType(node: Node | null | undefined): node is TSArrayType;
+declare function isTSArrayType<Opts extends Options<TSArrayType>>(node: Node | null | undefined, opts?: Opts | null): node is TSArrayType & Opts;
+declare function isTSTupleType(node: Node | null | undefined): node is TSTupleType;
+declare function isTSTupleType<Opts extends Options<TSTupleType>>(node: Node | null | undefined, opts?: Opts | null): node is TSTupleType & Opts;
+declare function isTSOptionalType(node: Node | null | undefined): node is TSOptionalType;
+declare function isTSOptionalType<Opts extends Options<TSOptionalType>>(node: Node | null | undefined, opts?: Opts | null): node is TSOptionalType & Opts;
+declare function isTSRestType(node: Node | null | undefined): node is TSRestType;
+declare function isTSRestType<Opts extends Options<TSRestType>>(node: Node | null | undefined, opts?: Opts | null): node is TSRestType & Opts;
+declare function isTSNamedTupleMember(node: Node | null | undefined): node is TSNamedTupleMember;
+declare function isTSNamedTupleMember<Opts extends Options<TSNamedTupleMember>>(node: Node | null | undefined, opts?: Opts | null): node is TSNamedTupleMember & Opts;
+declare function isTSUnionType(node: Node | null | undefined): node is TSUnionType;
+declare function isTSUnionType<Opts extends Options<TSUnionType>>(node: Node | null | undefined, opts?: Opts | null): node is TSUnionType & Opts;
+declare function isTSIntersectionType(node: Node | null | undefined): node is TSIntersectionType;
+declare function isTSIntersectionType<Opts extends Options<TSIntersectionType>>(node: Node | null | undefined, opts?: Opts | null): node is TSIntersectionType & Opts;
+declare function isTSConditionalType(node: Node | null | undefined): node is TSConditionalType;
+declare function isTSConditionalType<Opts extends Options<TSConditionalType>>(node: Node | null | undefined, opts?: Opts | null): node is TSConditionalType & Opts;
+declare function isTSInferType(node: Node | null | undefined): node is TSInferType;
+declare function isTSInferType<Opts extends Options<TSInferType>>(node: Node | null | undefined, opts?: Opts | null): node is TSInferType & Opts;
+declare function isTSParenthesizedType(node: Node | null | undefined): node is TSParenthesizedType;
+declare function isTSParenthesizedType<Opts extends Options<TSParenthesizedType>>(node: Node | null | undefined, opts?: Opts | null): node is TSParenthesizedType & Opts;
+declare function isTSTypeOperator(node: Node | null | undefined): node is TSTypeOperator;
+declare function isTSTypeOperator<Opts extends Options<TSTypeOperator>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeOperator & Opts;
+declare function isTSIndexedAccessType(node: Node | null | undefined): node is TSIndexedAccessType;
+declare function isTSIndexedAccessType<Opts extends Options<TSIndexedAccessType>>(node: Node | null | undefined, opts?: Opts | null): node is TSIndexedAccessType & Opts;
+declare function isTSMappedType(node: Node | null | undefined): node is TSMappedType;
+declare function isTSMappedType<Opts extends Options<TSMappedType>>(node: Node | null | undefined, opts?: Opts | null): node is TSMappedType & Opts;
+declare function isTSTemplateLiteralType(node: Node | null | undefined): node is TSTemplateLiteralType;
+declare function isTSTemplateLiteralType<Opts extends Options<TSTemplateLiteralType>>(node: Node | null | undefined, opts?: Opts | null): node is TSTemplateLiteralType & Opts;
+declare function isTSLiteralType(node: Node | null | undefined): node is TSLiteralType;
+declare function isTSLiteralType<Opts extends Options<TSLiteralType>>(node: Node | null | undefined, opts?: Opts | null): node is TSLiteralType & Opts;
+declare function isTSExpressionWithTypeArguments(node: Node | null | undefined): node is TSExpressionWithTypeArguments;
+declare function isTSExpressionWithTypeArguments<Opts extends Options<TSExpressionWithTypeArguments>>(node: Node | null | undefined, opts?: Opts | null): node is TSExpressionWithTypeArguments & Opts;
+declare function isTSInterfaceDeclaration(node: Node | null | undefined): node is TSInterfaceDeclaration;
+declare function isTSInterfaceDeclaration<Opts extends Options<TSInterfaceDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSInterfaceDeclaration & Opts;
+declare function isTSInterfaceBody(node: Node | null | undefined): node is TSInterfaceBody;
+declare function isTSInterfaceBody<Opts extends Options<TSInterfaceBody>>(node: Node | null | undefined, opts?: Opts | null): node is TSInterfaceBody & Opts;
+declare function isTSTypeAliasDeclaration(node: Node | null | undefined): node is TSTypeAliasDeclaration;
+declare function isTSTypeAliasDeclaration<Opts extends Options<TSTypeAliasDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAliasDeclaration & Opts;
+declare function isTSInstantiationExpression(node: Node | null | undefined): node is TSInstantiationExpression;
+declare function isTSInstantiationExpression<Opts extends Options<TSInstantiationExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TSInstantiationExpression & Opts;
+declare function isTSAsExpression(node: Node | null | undefined): node is TSAsExpression;
+declare function isTSAsExpression<Opts extends Options<TSAsExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TSAsExpression & Opts;
+declare function isTSSatisfiesExpression(node: Node | null | undefined): node is TSSatisfiesExpression;
+declare function isTSSatisfiesExpression<Opts extends Options<TSSatisfiesExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TSSatisfiesExpression & Opts;
+declare function isTSTypeAssertion(node: Node | null | undefined): node is TSTypeAssertion;
+declare function isTSTypeAssertion<Opts extends Options<TSTypeAssertion>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAssertion & Opts;
+declare function isTSEnumBody(node: Node | null | undefined): node is TSEnumBody;
+declare function isTSEnumBody<Opts extends Options<TSEnumBody>>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumBody & Opts;
+declare function isTSEnumDeclaration(node: Node | null | undefined): node is TSEnumDeclaration;
+declare function isTSEnumDeclaration<Opts extends Options<TSEnumDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumDeclaration & Opts;
+declare function isTSEnumMember(node: Node | null | undefined): node is TSEnumMember;
+declare function isTSEnumMember<Opts extends Options<TSEnumMember>>(node: Node | null | undefined, opts?: Opts | null): node is TSEnumMember & Opts;
+declare function isTSModuleDeclaration(node: Node | null | undefined): node is TSModuleDeclaration;
+declare function isTSModuleDeclaration<Opts extends Options<TSModuleDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSModuleDeclaration & Opts;
+declare function isTSModuleBlock(node: Node | null | undefined): node is TSModuleBlock;
+declare function isTSModuleBlock<Opts extends Options<TSModuleBlock>>(node: Node | null | undefined, opts?: Opts | null): node is TSModuleBlock & Opts;
+declare function isTSImportType(node: Node | null | undefined): node is TSImportType;
+declare function isTSImportType<Opts extends Options<TSImportType>>(node: Node | null | undefined, opts?: Opts | null): node is TSImportType & Opts;
+declare function isTSImportEqualsDeclaration(node: Node | null | undefined): node is TSImportEqualsDeclaration;
+declare function isTSImportEqualsDeclaration<Opts extends Options<TSImportEqualsDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSImportEqualsDeclaration & Opts;
+declare function isTSExternalModuleReference(node: Node | null | undefined): node is TSExternalModuleReference;
+declare function isTSExternalModuleReference<Opts extends Options<TSExternalModuleReference>>(node: Node | null | undefined, opts?: Opts | null): node is TSExternalModuleReference & Opts;
+declare function isTSNonNullExpression(node: Node | null | undefined): node is TSNonNullExpression;
+declare function isTSNonNullExpression<Opts extends Options<TSNonNullExpression>>(node: Node | null | undefined, opts?: Opts | null): node is TSNonNullExpression & Opts;
+declare function isTSExportAssignment(node: Node | null | undefined): node is TSExportAssignment;
+declare function isTSExportAssignment<Opts extends Options<TSExportAssignment>>(node: Node | null | undefined, opts?: Opts | null): node is TSExportAssignment & Opts;
+declare function isTSNamespaceExportDeclaration(node: Node | null | undefined): node is TSNamespaceExportDeclaration;
+declare function isTSNamespaceExportDeclaration<Opts extends Options<TSNamespaceExportDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSNamespaceExportDeclaration & Opts;
+declare function isTSTypeAnnotation(node: Node | null | undefined): node is TSTypeAnnotation;
+declare function isTSTypeAnnotation<Opts extends Options<TSTypeAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeAnnotation & Opts;
+declare function isTSTypeParameterInstantiation(node: Node | null | undefined): node is TSTypeParameterInstantiation;
+declare function isTSTypeParameterInstantiation<Opts extends Options<TSTypeParameterInstantiation>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameterInstantiation & Opts;
+declare function isTSTypeParameterDeclaration(node: Node | null | undefined): node is TSTypeParameterDeclaration;
+declare function isTSTypeParameterDeclaration<Opts extends Options<TSTypeParameterDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameterDeclaration & Opts;
+declare function isTSTypeParameter(node: Node | null | undefined): node is TSTypeParameter;
+declare function isTSTypeParameter<Opts extends Options<TSTypeParameter>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeParameter & Opts;
+declare function isStandardized(node: Node | null | undefined): node is Standardized;
+declare function isStandardized<Opts extends Options<Standardized>>(node: Node | null | undefined, opts?: Opts | null): node is Standardized & Opts;
+declare function isExpression(node: Node | null | undefined): node is Expression;
+declare function isExpression<Opts extends Options<Expression>>(node: Node | null | undefined, opts?: Opts | null): node is Expression & Opts;
+declare function isBinary(node: Node | null | undefined): node is Binary;
+declare function isBinary<Opts extends Options<Binary>>(node: Node | null | undefined, opts?: Opts | null): node is Binary & Opts;
+declare function isScopable(node: Node | null | undefined): node is Scopable;
+declare function isScopable<Opts extends Options<Scopable>>(node: Node | null | undefined, opts?: Opts | null): node is Scopable & Opts;
+declare function isBlockParent(node: Node | null | undefined): node is BlockParent;
+declare function isBlockParent<Opts extends Options<BlockParent>>(node: Node | null | undefined, opts?: Opts | null): node is BlockParent & Opts;
+declare function isBlock(node: Node | null | undefined): node is Block;
+declare function isBlock<Opts extends Options<Block>>(node: Node | null | undefined, opts?: Opts | null): node is Block & Opts;
+declare function isStatement(node: Node | null | undefined): node is Statement;
+declare function isStatement<Opts extends Options<Statement>>(node: Node | null | undefined, opts?: Opts | null): node is Statement & Opts;
+declare function isTerminatorless(node: Node | null | undefined): node is Terminatorless;
+declare function isTerminatorless<Opts extends Options<Terminatorless>>(node: Node | null | undefined, opts?: Opts | null): node is Terminatorless & Opts;
+declare function isCompletionStatement(node: Node | null | undefined): node is CompletionStatement;
+declare function isCompletionStatement<Opts extends Options<CompletionStatement>>(node: Node | null | undefined, opts?: Opts | null): node is CompletionStatement & Opts;
+declare function isConditional(node: Node | null | undefined): node is Conditional;
+declare function isConditional<Opts extends Options<Conditional>>(node: Node | null | undefined, opts?: Opts | null): node is Conditional & Opts;
+declare function isLoop(node: Node | null | undefined): node is Loop;
+declare function isLoop<Opts extends Options<Loop>>(node: Node | null | undefined, opts?: Opts | null): node is Loop & Opts;
+declare function isWhile(node: Node | null | undefined): node is While;
+declare function isWhile<Opts extends Options<While>>(node: Node | null | undefined, opts?: Opts | null): node is While & Opts;
+declare function isExpressionWrapper(node: Node | null | undefined): node is ExpressionWrapper;
+declare function isExpressionWrapper<Opts extends Options<ExpressionWrapper>>(node: Node | null | undefined, opts?: Opts | null): node is ExpressionWrapper & Opts;
+declare function isFor(node: Node | null | undefined): node is For;
+declare function isFor<Opts extends Options<For>>(node: Node | null | undefined, opts?: Opts | null): node is For & Opts;
+declare function isForXStatement(node: Node | null | undefined): node is ForXStatement;
+declare function isForXStatement<Opts extends Options<ForXStatement>>(node: Node | null | undefined, opts?: Opts | null): node is ForXStatement & Opts;
+declare function isFunction(node: Node | null | undefined): node is Function;
+declare function isFunction<Opts extends Options<Function>>(node: Node | null | undefined, opts?: Opts | null): node is Function & Opts;
+declare function isFunctionParent(node: Node | null | undefined): node is FunctionParent;
+declare function isFunctionParent<Opts extends Options<FunctionParent>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionParent & Opts;
+declare function isPureish(node: Node | null | undefined): node is Pureish;
+declare function isPureish<Opts extends Options<Pureish>>(node: Node | null | undefined, opts?: Opts | null): node is Pureish & Opts;
+declare function isDeclaration(node: Node | null | undefined): node is Declaration;
+declare function isDeclaration<Opts extends Options<Declaration>>(node: Node | null | undefined, opts?: Opts | null): node is Declaration & Opts;
+declare function isFunctionParameter(node: Node | null | undefined): node is FunctionParameter;
+declare function isFunctionParameter<Opts extends Options<FunctionParameter>>(node: Node | null | undefined, opts?: Opts | null): node is FunctionParameter & Opts;
+declare function isPatternLike(node: Node | null | undefined): node is PatternLike;
+declare function isPatternLike<Opts extends Options<PatternLike>>(node: Node | null | undefined, opts?: Opts | null): node is PatternLike & Opts;
+declare function isLVal(node: Node | null | undefined): node is LVal;
+declare function isLVal<Opts extends Options<LVal>>(node: Node | null | undefined, opts?: Opts | null): node is LVal & Opts;
+declare function isTSEntityName(node: Node | null | undefined): node is TSEntityName;
+declare function isTSEntityName<Opts extends Options<TSEntityName>>(node: Node | null | undefined, opts?: Opts | null): node is TSEntityName & Opts;
+declare function isLiteral(node: Node | null | undefined): node is Literal;
+declare function isLiteral<Opts extends Options<Literal>>(node: Node | null | undefined, opts?: Opts | null): node is Literal & Opts;
+declare function isUserWhitespacable(node: Node | null | undefined): node is UserWhitespacable;
+declare function isUserWhitespacable<Opts extends Options<UserWhitespacable>>(node: Node | null | undefined, opts?: Opts | null): node is UserWhitespacable & Opts;
+declare function isMethod(node: Node | null | undefined): node is Method;
+declare function isMethod<Opts extends Options<Method>>(node: Node | null | undefined, opts?: Opts | null): node is Method & Opts;
+declare function isObjectMember(node: Node | null | undefined): node is ObjectMember;
+declare function isObjectMember<Opts extends Options<ObjectMember>>(node: Node | null | undefined, opts?: Opts | null): node is ObjectMember & Opts;
+declare function isProperty(node: Node | null | undefined): node is Property;
+declare function isProperty<Opts extends Options<Property>>(node: Node | null | undefined, opts?: Opts | null): node is Property & Opts;
+declare function isUnaryLike(node: Node | null | undefined): node is UnaryLike;
+declare function isUnaryLike<Opts extends Options<UnaryLike>>(node: Node | null | undefined, opts?: Opts | null): node is UnaryLike & Opts;
+declare function isPattern(node: Node | null | undefined): node is Pattern;
+declare function isPattern<Opts extends Options<Pattern>>(node: Node | null | undefined, opts?: Opts | null): node is Pattern & Opts;
+declare function isClass(node: Node | null | undefined): node is Class;
+declare function isClass<Opts extends Options<Class>>(node: Node | null | undefined, opts?: Opts | null): node is Class & Opts;
+declare function isImportOrExportDeclaration(node: Node | null | undefined): node is ImportOrExportDeclaration;
+declare function isImportOrExportDeclaration<Opts extends Options<ImportOrExportDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts;
+declare function isExportDeclaration(node: Node | null | undefined): node is ExportDeclaration;
+declare function isExportDeclaration<Opts extends Options<ExportDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ExportDeclaration & Opts;
+declare function isModuleSpecifier(node: Node | null | undefined): node is ModuleSpecifier;
+declare function isModuleSpecifier<Opts extends Options<ModuleSpecifier>>(node: Node | null | undefined, opts?: Opts | null): node is ModuleSpecifier & Opts;
+declare function isAccessor(node: Node | null | undefined): node is Accessor;
+declare function isAccessor<Opts extends Options<Accessor>>(node: Node | null | undefined, opts?: Opts | null): node is Accessor & Opts;
+declare function isPrivate(node: Node | null | undefined): node is Private;
+declare function isPrivate<Opts extends Options<Private>>(node: Node | null | undefined, opts?: Opts | null): node is Private & Opts;
+declare function isFlow(node: Node | null | undefined): node is Flow;
+declare function isFlow<Opts extends Options<Flow>>(node: Node | null | undefined, opts?: Opts | null): node is Flow & Opts;
+declare function isFlowType(node: Node | null | undefined): node is FlowType;
+declare function isFlowType<Opts extends Options<FlowType>>(node: Node | null | undefined, opts?: Opts | null): node is FlowType & Opts;
+declare function isFlowBaseAnnotation(node: Node | null | undefined): node is FlowBaseAnnotation;
+declare function isFlowBaseAnnotation<Opts extends Options<FlowBaseAnnotation>>(node: Node | null | undefined, opts?: Opts | null): node is FlowBaseAnnotation & Opts;
+declare function isFlowDeclaration(node: Node | null | undefined): node is FlowDeclaration;
+declare function isFlowDeclaration<Opts extends Options<FlowDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is FlowDeclaration & Opts;
+declare function isFlowPredicate(node: Node | null | undefined): node is FlowPredicate;
+declare function isFlowPredicate<Opts extends Options<FlowPredicate>>(node: Node | null | undefined, opts?: Opts | null): node is FlowPredicate & Opts;
+declare function isEnumBody(node: Node | null | undefined): node is EnumBody;
+declare function isEnumBody<Opts extends Options<EnumBody>>(node: Node | null | undefined, opts?: Opts | null): node is EnumBody & Opts;
+declare function isEnumMember(node: Node | null | undefined): node is EnumMember;
+declare function isEnumMember<Opts extends Options<EnumMember>>(node: Node | null | undefined, opts?: Opts | null): node is EnumMember & Opts;
+declare function isJSX(node: Node | null | undefined): node is JSX;
+declare function isJSX<Opts extends Options<JSX>>(node: Node | null | undefined, opts?: Opts | null): node is JSX & Opts;
+declare function isMiscellaneous(node: Node | null | undefined): node is Miscellaneous;
+declare function isMiscellaneous<Opts extends Options<Miscellaneous>>(node: Node | null | undefined, opts?: Opts | null): node is Miscellaneous & Opts;
+declare function isTypeScript(node: Node | null | undefined): node is TypeScript;
+declare function isTypeScript<Opts extends Options<TypeScript>>(node: Node | null | undefined, opts?: Opts | null): node is TypeScript & Opts;
+declare function isTSTypeElement(node: Node | null | undefined): node is TSTypeElement;
+declare function isTSTypeElement<Opts extends Options<TSTypeElement>>(node: Node | null | undefined, opts?: Opts | null): node is TSTypeElement & Opts;
+declare function isTSType(node: Node | null | undefined): node is TSType;
+declare function isTSType<Opts extends Options<TSType>>(node: Node | null | undefined, opts?: Opts | null): node is TSType & Opts;
+declare function isTSBaseType(node: Node | null | undefined): node is TSBaseType;
+declare function isTSBaseType<Opts extends Options<TSBaseType>>(node: Node | null | undefined, opts?: Opts | null): node is TSBaseType & Opts;
 /**
  * @deprecated Use `isNumericLiteral`
  */
-declare function isNumberLiteral(node: Node | null | undefined, opts?: Opts<NumberLiteral$1> | null): boolean;
+declare function isNumberLiteral(node: Node | null | undefined): boolean;
+declare function isNumberLiteral<Opts extends Options<NumberLiteral$1>>(node: Node | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isRegExpLiteral`
  */
-declare function isRegexLiteral(node: Node | null | undefined, opts?: Opts<RegexLiteral$1> | null): boolean;
+declare function isRegexLiteral(node: Node | null | undefined): boolean;
+declare function isRegexLiteral<Opts extends Options<RegexLiteral$1>>(node: Node | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isRestElement`
  */
-declare function isRestProperty(node: Node | null | undefined, opts?: Opts<RestProperty$1> | null): boolean;
+declare function isRestProperty(node: Node | null | undefined): boolean;
+declare function isRestProperty<Opts extends Options<RestProperty$1>>(node: Node | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isSpreadElement`
  */
-declare function isSpreadProperty(node: Node | null | undefined, opts?: Opts<SpreadProperty$1> | null): boolean;
+declare function isSpreadProperty(node: Node | null | undefined): boolean;
+declare function isSpreadProperty<Opts extends Options<SpreadProperty$1>>(node: Node | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isImportOrExportDeclaration`
  */
-declare function isModuleDeclaration(node: Node | null | undefined, opts?: Opts<ModuleDeclaration> | null): node is ImportOrExportDeclaration;
+declare function isModuleDeclaration<Opts extends Options<ModuleDeclaration>>(node: Node | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts;
 
 declare function deprecationWarning(oldName: string, newName: string, prefix?: string, cacheKey?: string): void;
 
@@ -3305,4 +3614,4 @@ declare const react: {
     buildChildren: typeof buildChildren;
 };
 
-export { ACCESSOR_TYPES, ALIAS_KEYS, ASSIGNMENT_OPERATORS, Accessor, Aliases, AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BINARY_OPERATORS, BINARY_TYPES, BLOCKPARENT_TYPES, BLOCK_TYPES, BOOLEAN_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS, BOOLEAN_UNARY_OPERATORS, BUILDER_KEYS, BigIntLiteral, Binary, BinaryExpression, BindExpression, Block, BlockParent, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CLASS_TYPES, COMMENT_KEYS, COMPARISON_BINARY_OPERATORS, COMPLETIONSTATEMENT_TYPES, CONDITIONAL_TYPES, CallExpression, CatchClause, Class, ClassAccessorProperty, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, Comment, CommentBlock, CommentLine, CommentTypeShorthand, CompletionStatement, Conditional, ConditionalExpression, ContinueStatement, DECLARATION_TYPES, DEPRECATED_ALIASES, DEPRECATED_KEYS, DebuggerStatement, DecimalLiteral, Declaration, DeclareClass, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DeclaredPredicate, Decorator, DeprecatedAliases, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, ENUMBODY_TYPES, ENUMMEMBER_TYPES, EQUALITY_BINARY_OPERATORS, EXPORTDECLARATION_TYPES, EXPRESSIONWRAPPER_TYPES, EXPRESSION_TYPES, EmptyStatement, EmptyTypeAnnotation, EnumBody, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, ExpressionWrapper, FLATTENABLE_KEYS, FLIPPED_ALIAS_KEYS, FLOWBASEANNOTATION_TYPES, FLOWDECLARATION_TYPES, FLOWPREDICATE_TYPES, FLOWTYPE_TYPES, FLOW_TYPES, FORXSTATEMENT_TYPES, FOR_INIT_KEYS, FOR_TYPES, FUNCTIONPARAMETER_TYPES, FUNCTIONPARENT_TYPES, FUNCTION_TYPES, FieldOptions, File, Flow, FlowBaseAnnotation, FlowDeclaration, FlowPredicate, FlowType, For, ForInStatement, ForOfStatement, ForStatement, ForXStatement, Function, FunctionDeclaration, FunctionExpression, FunctionParameter, FunctionParent, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, IMMUTABLE_TYPES, IMPORTOREXPORTDECLARATION_TYPES, INHERIT_KEYS, Identifier, IfStatement, Immutable, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportOrExportDeclaration, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSX, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, JSX_TYPES, LITERAL_TYPES, LOGICAL_OPERATORS, LOOP_TYPES, LVAL_TYPES, LVal, LabeledStatement, Literal, LogicalExpression, Loop, METHOD_TYPES, MISCELLANEOUS_TYPES, MODULEDECLARATION_TYPES, MODULESPECIFIER_TYPES, MemberExpression, MetaProperty, Method, Miscellaneous, MixedTypeAnnotation, ModuleDeclaration, ModuleExpression, ModuleSpecifier, NODE_FIELDS, NODE_PARENT_VALIDATIONS, NUMBER_BINARY_OPERATORS, NUMBER_UNARY_OPERATORS, NewExpression, Node, Noop, NullLiteral, NullLiteralTypeAnnotation, NullableTypeAnnotation, NumberLiteral$1 as NumberLiteral, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, OBJECTMEMBER_TYPES, ObjectExpression, ObjectMember, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, PATTERNLIKE_TYPES, PATTERN_TYPES, PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS, PRIVATE_TYPES, PROPERTY_TYPES, PUREISH_TYPES, ParentMaps, ParenthesizedExpression, Pattern, PatternLike, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, Private, PrivateName, Program, Property, Pureish, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RegexLiteral$1 as RegexLiteral, Options as RemovePropertiesOptions, RestElement, RestProperty$1 as RestProperty, ReturnStatement, SCOPABLE_TYPES, STANDARDIZED_TYPES, STATEMENT_OR_BLOCK_KEYS, STATEMENT_TYPES, STRING_UNARY_OPERATORS, Scopable, SequenceExpression, SourceLocation, SpreadElement, SpreadProperty$1 as SpreadProperty, Standardized, Statement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TERMINATORLESS_TYPES, TSAnyKeyword, TSArrayType, TSAsExpression, TSBASETYPE_TYPES, TSBaseType, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSDeclareMethod, TSENTITYNAME_TYPES, TSEntityName, TSEnumBody, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexSignature, TSIndexedAccessType, TSInferType, TSInstantiationExpression, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSSatisfiesExpression, TSStringKeyword, TSSymbolKeyword, TSTYPEELEMENT_TYPES, TSTYPE_TYPES, TSTemplateLiteralType, TSThisType, TSTupleType, TSType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeElement, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TYPES, TYPESCRIPT_TYPES, TaggedTemplateExpression, TemplateElement, TemplateLiteral, Terminatorless, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TraversalAncestors, TraversalHandler, TraversalHandlers, TryStatement, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypeScript, TypeofTypeAnnotation, UNARYLIKE_TYPES, UNARY_OPERATORS, UPDATE_OPERATORS, USERWHITESPACABLE_TYPES, UnaryExpression, UnaryLike, UnionTypeAnnotation, UpdateExpression, UserWhitespacable, V8IntrinsicIdentifier, VISITOR_KEYS, VariableDeclaration, VariableDeclarator, Variance, VoidPattern, VoidTypeAnnotation, WHILE_TYPES, While, WhileStatement, WithStatement, YieldExpression, deprecationWarning as __internal__deprecationWarning, addComment, addComments, anyTypeAnnotation, appendToMemberExpression, argumentPlaceholder, arrayExpression, arrayPattern, arrayTypeAnnotation, arrowFunctionExpression, assertAccessor, assertAnyTypeAnnotation, assertArgumentPlaceholder, assertArrayExpression, assertArrayPattern, assertArrayTypeAnnotation, assertArrowFunctionExpression, assertAssignmentExpression, assertAssignmentPattern, assertAwaitExpression, assertBigIntLiteral, assertBinary, assertBinaryExpression, assertBindExpression, assertBlock, assertBlockParent, assertBlockStatement, assertBooleanLiteral, assertBooleanLiteralTypeAnnotation, assertBooleanTypeAnnotation, assertBreakStatement, assertCallExpression, assertCatchClause, assertClass, assertClassAccessorProperty, assertClassBody, assertClassDeclaration, assertClassExpression, assertClassImplements, assertClassMethod, assertClassPrivateMethod, assertClassPrivateProperty, assertClassProperty, assertCompletionStatement, assertConditional, assertConditionalExpression, assertContinueStatement, assertDebuggerStatement, assertDecimalLiteral, assertDeclaration, assertDeclareClass, assertDeclareExportAllDeclaration, assertDeclareExportDeclaration, assertDeclareFunction, assertDeclareInterface, assertDeclareModule, assertDeclareModuleExports, assertDeclareOpaqueType, assertDeclareTypeAlias, assertDeclareVariable, assertDeclaredPredicate, assertDecorator, assertDirective, assertDirectiveLiteral, assertDoExpression, assertDoWhileStatement, assertEmptyStatement, assertEmptyTypeAnnotation, assertEnumBody, assertEnumBooleanBody, assertEnumBooleanMember, assertEnumDeclaration, assertEnumDefaultedMember, assertEnumMember, assertEnumNumberBody, assertEnumNumberMember, assertEnumStringBody, assertEnumStringMember, assertEnumSymbolBody, assertExistsTypeAnnotation, assertExportAllDeclaration, assertExportDeclaration, assertExportDefaultDeclaration, assertExportDefaultSpecifier, assertExportNamedDeclaration, assertExportNamespaceSpecifier, assertExportSpecifier, assertExpression, assertExpressionStatement, assertExpressionWrapper, assertFile, assertFlow, assertFlowBaseAnnotation, assertFlowDeclaration, assertFlowPredicate, assertFlowType, assertFor, assertForInStatement, assertForOfStatement, assertForStatement, assertForXStatement, assertFunction, assertFunctionDeclaration, assertFunctionExpression, assertFunctionParameter, assertFunctionParent, assertFunctionTypeAnnotation, assertFunctionTypeParam, assertGenericTypeAnnotation, assertIdentifier, assertIfStatement, assertImmutable, assertImport, assertImportAttribute, assertImportDeclaration, assertImportDefaultSpecifier, assertImportExpression, assertImportNamespaceSpecifier, assertImportOrExportDeclaration, assertImportSpecifier, assertIndexedAccessType, assertInferredPredicate, assertInterfaceDeclaration, assertInterfaceExtends, assertInterfaceTypeAnnotation, assertInterpreterDirective, assertIntersectionTypeAnnotation, assertJSX, assertJSXAttribute, assertJSXClosingElement, assertJSXClosingFragment, assertJSXElement, assertJSXEmptyExpression, assertJSXExpressionContainer, assertJSXFragment, assertJSXIdentifier, assertJSXMemberExpression, assertJSXNamespacedName, assertJSXOpeningElement, assertJSXOpeningFragment, assertJSXSpreadAttribute, assertJSXSpreadChild, assertJSXText, assertLVal, assertLabeledStatement, assertLiteral, assertLogicalExpression, assertLoop, assertMemberExpression, assertMetaProperty, assertMethod, assertMiscellaneous, assertMixedTypeAnnotation, assertModuleDeclaration, assertModuleExpression, assertModuleSpecifier, assertNewExpression, assertNode, assertNoop, assertNullLiteral, assertNullLiteralTypeAnnotation, assertNullableTypeAnnotation, assertNumberLiteral, assertNumberLiteralTypeAnnotation, assertNumberTypeAnnotation, assertNumericLiteral, assertObjectExpression, assertObjectMember, assertObjectMethod, assertObjectPattern, assertObjectProperty, assertObjectTypeAnnotation, assertObjectTypeCallProperty, assertObjectTypeIndexer, assertObjectTypeInternalSlot, assertObjectTypeProperty, assertObjectTypeSpreadProperty, assertOpaqueType, assertOptionalCallExpression, assertOptionalIndexedAccessType, assertOptionalMemberExpression, assertParenthesizedExpression, assertPattern, assertPatternLike, assertPipelineBareFunction, assertPipelinePrimaryTopicReference, assertPipelineTopicExpression, assertPlaceholder, assertPrivate, assertPrivateName, assertProgram, assertProperty, assertPureish, assertQualifiedTypeIdentifier, assertRecordExpression, assertRegExpLiteral, assertRegexLiteral, assertRestElement, assertRestProperty, assertReturnStatement, assertScopable, assertSequenceExpression, assertSpreadElement, assertSpreadProperty, assertStandardized, assertStatement, assertStaticBlock, assertStringLiteral, assertStringLiteralTypeAnnotation, assertStringTypeAnnotation, assertSuper, assertSwitchCase, assertSwitchStatement, assertSymbolTypeAnnotation, assertTSAnyKeyword, assertTSArrayType, assertTSAsExpression, assertTSBaseType, assertTSBigIntKeyword, assertTSBooleanKeyword, assertTSCallSignatureDeclaration, assertTSConditionalType, assertTSConstructSignatureDeclaration, assertTSConstructorType, assertTSDeclareFunction, assertTSDeclareMethod, assertTSEntityName, assertTSEnumBody, assertTSEnumDeclaration, assertTSEnumMember, assertTSExportAssignment, assertTSExpressionWithTypeArguments, assertTSExternalModuleReference, assertTSFunctionType, assertTSImportEqualsDeclaration, assertTSImportType, assertTSIndexSignature, assertTSIndexedAccessType, assertTSInferType, assertTSInstantiationExpression, assertTSInterfaceBody, assertTSInterfaceDeclaration, assertTSIntersectionType, assertTSIntrinsicKeyword, assertTSLiteralType, assertTSMappedType, assertTSMethodSignature, assertTSModuleBlock, assertTSModuleDeclaration, assertTSNamedTupleMember, assertTSNamespaceExportDeclaration, assertTSNeverKeyword, assertTSNonNullExpression, assertTSNullKeyword, assertTSNumberKeyword, assertTSObjectKeyword, assertTSOptionalType, assertTSParameterProperty, assertTSParenthesizedType, assertTSPropertySignature, assertTSQualifiedName, assertTSRestType, assertTSSatisfiesExpression, assertTSStringKeyword, assertTSSymbolKeyword, assertTSTemplateLiteralType, assertTSThisType, assertTSTupleType, assertTSType, assertTSTypeAliasDeclaration, assertTSTypeAnnotation, assertTSTypeAssertion, assertTSTypeElement, assertTSTypeLiteral, assertTSTypeOperator, assertTSTypeParameter, assertTSTypeParameterDeclaration, assertTSTypeParameterInstantiation, assertTSTypePredicate, assertTSTypeQuery, assertTSTypeReference, assertTSUndefinedKeyword, assertTSUnionType, assertTSUnknownKeyword, assertTSVoidKeyword, assertTaggedTemplateExpression, assertTemplateElement, assertTemplateLiteral, assertTerminatorless, assertThisExpression, assertThisTypeAnnotation, assertThrowStatement, assertTopicReference, assertTryStatement, assertTupleExpression, assertTupleTypeAnnotation, assertTypeAlias, assertTypeAnnotation, assertTypeCastExpression, assertTypeParameter, assertTypeParameterDeclaration, assertTypeParameterInstantiation, assertTypeScript, assertTypeofTypeAnnotation, assertUnaryExpression, assertUnaryLike, assertUnionTypeAnnotation, assertUpdateExpression, assertUserWhitespacable, assertV8IntrinsicIdentifier, assertVariableDeclaration, assertVariableDeclarator, assertVariance, assertVoidPattern, assertVoidTypeAnnotation, assertWhile, assertWhileStatement, assertWithStatement, assertYieldExpression, assignmentExpression, assignmentPattern, awaitExpression, bigIntLiteral, binaryExpression, bindExpression, blockStatement, booleanLiteral, booleanLiteralTypeAnnotation, booleanTypeAnnotation, breakStatement, buildMatchMemberExpression, buildUndefinedNode, callExpression, catchClause, classAccessorProperty, classBody, classDeclaration, classExpression, classImplements, classMethod, classPrivateMethod, classPrivateProperty, classProperty, clone, cloneDeep, cloneDeepWithoutLoc, cloneNode, cloneWithoutLoc, conditionalExpression, continueStatement, createFlowUnionType, createTSUnionType, _default$4 as createTypeAnnotationBasedOnTypeof, createFlowUnionType as createUnionTypeAnnotation, debuggerStatement, decimalLiteral, declareClass, declareExportAllDeclaration, declareExportDeclaration, declareFunction, declareInterface, declareModule, declareModuleExports, declareOpaqueType, declareTypeAlias, declareVariable, declaredPredicate, decorator, directive, directiveLiteral, doExpression, doWhileStatement, emptyStatement, emptyTypeAnnotation, ensureBlock, enumBooleanBody, enumBooleanMember, enumDeclaration, enumDefaultedMember, enumNumberBody, enumNumberMember, enumStringBody, enumStringMember, enumSymbolBody, existsTypeAnnotation, exportAllDeclaration, exportDefaultDeclaration, exportDefaultSpecifier, exportNamedDeclaration, exportNamespaceSpecifier, exportSpecifier, expressionStatement, file, forInStatement, forOfStatement, forStatement, functionDeclaration, functionExpression, functionTypeAnnotation, functionTypeParam, genericTypeAnnotation, getAssignmentIdentifiers, getBindingIdentifiers, getFunctionName, _default as getOuterBindingIdentifiers, identifier, ifStatement, _import as import, importAttribute, importDeclaration, importDefaultSpecifier, importExpression, importNamespaceSpecifier, importSpecifier, indexedAccessType, inferredPredicate, inheritInnerComments, inheritLeadingComments, inheritTrailingComments, inherits, inheritsComments, interfaceDeclaration, interfaceExtends, interfaceTypeAnnotation, interpreterDirective, intersectionTypeAnnotation, is, isAccessor, isAnyTypeAnnotation, isArgumentPlaceholder, isArrayExpression, isArrayPattern, isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAssignmentPattern, isAwaitExpression, isBigIntLiteral, isBinary, isBinaryExpression, isBindExpression, isBinding, isBlock, isBlockParent, isBlockScoped, isBlockStatement, isBooleanLiteral, isBooleanLiteralTypeAnnotation, isBooleanTypeAnnotation, isBreakStatement, isCallExpression, isCatchClause, isClass, isClassAccessorProperty, isClassBody, isClassDeclaration, isClassExpression, isClassImplements, isClassMethod, isClassPrivateMethod, isClassPrivateProperty, isClassProperty, isCompletionStatement, isConditional, isConditionalExpression, isContinueStatement, isDebuggerStatement, isDecimalLiteral, isDeclaration, isDeclareClass, isDeclareExportAllDeclaration, isDeclareExportDeclaration, isDeclareFunction, isDeclareInterface, isDeclareModule, isDeclareModuleExports, isDeclareOpaqueType, isDeclareTypeAlias, isDeclareVariable, isDeclaredPredicate, isDecorator, isDirective, isDirectiveLiteral, isDoExpression, isDoWhileStatement, isEmptyStatement, isEmptyTypeAnnotation, isEnumBody, isEnumBooleanBody, isEnumBooleanMember, isEnumDeclaration, isEnumDefaultedMember, isEnumMember, isEnumNumberBody, isEnumNumberMember, isEnumStringBody, isEnumStringMember, isEnumSymbolBody, isExistsTypeAnnotation, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportDefaultSpecifier, isExportNamedDeclaration, isExportNamespaceSpecifier, isExportSpecifier, isExpression, isExpressionStatement, isExpressionWrapper, isFile, isFlow, isFlowBaseAnnotation, isFlowDeclaration, isFlowPredicate, isFlowType, isFor, isForInStatement, isForOfStatement, isForStatement, isForXStatement, isFunction, isFunctionDeclaration, isFunctionExpression, isFunctionParameter, isFunctionParent, isFunctionTypeAnnotation, isFunctionTypeParam, isGenericTypeAnnotation, isIdentifier, isIfStatement, isImmutable, isImport, isImportAttribute, isImportDeclaration, isImportDefaultSpecifier, isImportExpression, isImportNamespaceSpecifier, isImportOrExportDeclaration, isImportSpecifier, isIndexedAccessType, isInferredPredicate, isInterfaceDeclaration, isInterfaceExtends, isInterfaceTypeAnnotation, isInterpreterDirective, isIntersectionTypeAnnotation, isJSX, isJSXAttribute, isJSXClosingElement, isJSXClosingFragment, isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXFragment, isJSXIdentifier, isJSXMemberExpression, isJSXNamespacedName, isJSXOpeningElement, isJSXOpeningFragment, isJSXSpreadAttribute, isJSXSpreadChild, isJSXText, isLVal, isLabeledStatement, isLet, isLiteral, isLogicalExpression, isLoop, isMemberExpression, isMetaProperty, isMethod, isMiscellaneous, isMixedTypeAnnotation, isModuleDeclaration, isModuleExpression, isModuleSpecifier, isNewExpression, isNode, isNodesEquivalent, isNoop, isNullLiteral, isNullLiteralTypeAnnotation, isNullableTypeAnnotation, isNumberLiteral, isNumberLiteralTypeAnnotation, isNumberTypeAnnotation, isNumericLiteral, isObjectExpression, isObjectMember, isObjectMethod, isObjectPattern, isObjectProperty, isObjectTypeAnnotation, isObjectTypeCallProperty, isObjectTypeIndexer, isObjectTypeInternalSlot, isObjectTypeProperty, isObjectTypeSpreadProperty, isOpaqueType, isOptionalCallExpression, isOptionalIndexedAccessType, isOptionalMemberExpression, isParenthesizedExpression, isPattern, isPatternLike, isPipelineBareFunction, isPipelinePrimaryTopicReference, isPipelineTopicExpression, isPlaceholder, isPlaceholderType, isPrivate, isPrivateName, isProgram, isProperty, isPureish, isQualifiedTypeIdentifier, isRecordExpression, isReferenced, isRegExpLiteral, isRegexLiteral, isRestElement, isRestProperty, isReturnStatement, isScopable, isScope, isSequenceExpression, isSpecifierDefault, isSpreadElement, isSpreadProperty, isStandardized, isStatement, isStaticBlock, isStringLiteral, isStringLiteralTypeAnnotation, isStringTypeAnnotation, isSuper, isSwitchCase, isSwitchStatement, isSymbolTypeAnnotation, isTSAnyKeyword, isTSArrayType, isTSAsExpression, isTSBaseType, isTSBigIntKeyword, isTSBooleanKeyword, isTSCallSignatureDeclaration, isTSConditionalType, isTSConstructSignatureDeclaration, isTSConstructorType, isTSDeclareFunction, isTSDeclareMethod, isTSEntityName, isTSEnumBody, isTSEnumDeclaration, isTSEnumMember, isTSExportAssignment, isTSExpressionWithTypeArguments, isTSExternalModuleReference, isTSFunctionType, isTSImportEqualsDeclaration, isTSImportType, isTSIndexSignature, isTSIndexedAccessType, isTSInferType, isTSInstantiationExpression, isTSInterfaceBody, isTSInterfaceDeclaration, isTSIntersectionType, isTSIntrinsicKeyword, isTSLiteralType, isTSMappedType, isTSMethodSignature, isTSModuleBlock, isTSModuleDeclaration, isTSNamedTupleMember, isTSNamespaceExportDeclaration, isTSNeverKeyword, isTSNonNullExpression, isTSNullKeyword, isTSNumberKeyword, isTSObjectKeyword, isTSOptionalType, isTSParameterProperty, isTSParenthesizedType, isTSPropertySignature, isTSQualifiedName, isTSRestType, isTSSatisfiesExpression, isTSStringKeyword, isTSSymbolKeyword, isTSTemplateLiteralType, isTSThisType, isTSTupleType, isTSType, isTSTypeAliasDeclaration, isTSTypeAnnotation, isTSTypeAssertion, isTSTypeElement, isTSTypeLiteral, isTSTypeOperator, isTSTypeParameter, isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isTSTypePredicate, isTSTypeQuery, isTSTypeReference, isTSUndefinedKeyword, isTSUnionType, isTSUnknownKeyword, isTSVoidKeyword, isTaggedTemplateExpression, isTemplateElement, isTemplateLiteral, isTerminatorless, isThisExpression, isThisTypeAnnotation, isThrowStatement, isTopicReference, isTryStatement, isTupleExpression, isTupleTypeAnnotation, isType, isTypeAlias, isTypeAnnotation, isTypeCastExpression, isTypeParameter, isTypeParameterDeclaration, isTypeParameterInstantiation, isTypeScript, isTypeofTypeAnnotation, isUnaryExpression, isUnaryLike, isUnionTypeAnnotation, isUpdateExpression, isUserWhitespacable, isV8IntrinsicIdentifier, isValidES3Identifier, isValidIdentifier, isVar, isVariableDeclaration, isVariableDeclarator, isVariance, isVoidPattern, isVoidTypeAnnotation, isWhile, isWhileStatement, isWithStatement, isYieldExpression, jsxAttribute as jSXAttribute, jsxClosingElement as jSXClosingElement, jsxClosingFragment as jSXClosingFragment, jsxElement as jSXElement, jsxEmptyExpression as jSXEmptyExpression, jsxExpressionContainer as jSXExpressionContainer, jsxFragment as jSXFragment, jsxIdentifier as jSXIdentifier, jsxMemberExpression as jSXMemberExpression, jsxNamespacedName as jSXNamespacedName, jsxOpeningElement as jSXOpeningElement, jsxOpeningFragment as jSXOpeningFragment, jsxSpreadAttribute as jSXSpreadAttribute, jsxSpreadChild as jSXSpreadChild, jsxText as jSXText, jsxAttribute, jsxClosingElement, jsxClosingFragment, jsxElement, jsxEmptyExpression, jsxExpressionContainer, jsxFragment, jsxIdentifier, jsxMemberExpression, jsxNamespacedName, jsxOpeningElement, jsxOpeningFragment, jsxSpreadAttribute, jsxSpreadChild, jsxText, labeledStatement, logicalExpression, matchesPattern, memberExpression, metaProperty, mixedTypeAnnotation, moduleExpression, newExpression, noop, nullLiteral, nullLiteralTypeAnnotation, nullableTypeAnnotation, NumberLiteral as numberLiteral, numberLiteralTypeAnnotation, numberTypeAnnotation, numericLiteral, objectExpression, objectMethod, objectPattern, objectProperty, objectTypeAnnotation, objectTypeCallProperty, objectTypeIndexer, objectTypeInternalSlot, objectTypeProperty, objectTypeSpreadProperty, opaqueType, optionalCallExpression, optionalIndexedAccessType, optionalMemberExpression, parenthesizedExpression, pipelineBareFunction, pipelinePrimaryTopicReference, pipelineTopicExpression, placeholder, prependToMemberExpression, privateName, program, qualifiedTypeIdentifier, react, recordExpression, regExpLiteral, RegexLiteral as regexLiteral, removeComments, removeProperties, removePropertiesDeep, removeTypeDuplicates, restElement, RestProperty as restProperty, returnStatement, sequenceExpression, shallowEqual, spreadElement, SpreadProperty as spreadProperty, staticBlock, stringLiteral, stringLiteralTypeAnnotation, stringTypeAnnotation, _super as super, switchCase, switchStatement, symbolTypeAnnotation, tsAnyKeyword as tSAnyKeyword, tsArrayType as tSArrayType, tsAsExpression as tSAsExpression, tsBigIntKeyword as tSBigIntKeyword, tsBooleanKeyword as tSBooleanKeyword, tsCallSignatureDeclaration as tSCallSignatureDeclaration, tsConditionalType as tSConditionalType, tsConstructSignatureDeclaration as tSConstructSignatureDeclaration, tsConstructorType as tSConstructorType, tsDeclareFunction as tSDeclareFunction, tsDeclareMethod as tSDeclareMethod, tsEnumBody as tSEnumBody, tsEnumDeclaration as tSEnumDeclaration, tsEnumMember as tSEnumMember, tsExportAssignment as tSExportAssignment, tsExpressionWithTypeArguments as tSExpressionWithTypeArguments, tsExternalModuleReference as tSExternalModuleReference, tsFunctionType as tSFunctionType, tsImportEqualsDeclaration as tSImportEqualsDeclaration, tsImportType as tSImportType, tsIndexSignature as tSIndexSignature, tsIndexedAccessType as tSIndexedAccessType, tsInferType as tSInferType, tsInstantiationExpression as tSInstantiationExpression, tsInterfaceBody as tSInterfaceBody, tsInterfaceDeclaration as tSInterfaceDeclaration, tsIntersectionType as tSIntersectionType, tsIntrinsicKeyword as tSIntrinsicKeyword, tsLiteralType as tSLiteralType, tsMappedType as tSMappedType, tsMethodSignature as tSMethodSignature, tsModuleBlock as tSModuleBlock, tsModuleDeclaration as tSModuleDeclaration, tsNamedTupleMember as tSNamedTupleMember, tsNamespaceExportDeclaration as tSNamespaceExportDeclaration, tsNeverKeyword as tSNeverKeyword, tsNonNullExpression as tSNonNullExpression, tsNullKeyword as tSNullKeyword, tsNumberKeyword as tSNumberKeyword, tsObjectKeyword as tSObjectKeyword, tsOptionalType as tSOptionalType, tsParameterProperty as tSParameterProperty, tsParenthesizedType as tSParenthesizedType, tsPropertySignature as tSPropertySignature, tsQualifiedName as tSQualifiedName, tsRestType as tSRestType, tsSatisfiesExpression as tSSatisfiesExpression, tsStringKeyword as tSStringKeyword, tsSymbolKeyword as tSSymbolKeyword, tsTemplateLiteralType as tSTemplateLiteralType, tsThisType as tSThisType, tsTupleType as tSTupleType, tsTypeAliasDeclaration as tSTypeAliasDeclaration, tsTypeAnnotation as tSTypeAnnotation, tsTypeAssertion as tSTypeAssertion, tsTypeLiteral as tSTypeLiteral, tsTypeOperator as tSTypeOperator, tsTypeParameter as tSTypeParameter, tsTypeParameterDeclaration as tSTypeParameterDeclaration, tsTypeParameterInstantiation as tSTypeParameterInstantiation, tsTypePredicate as tSTypePredicate, tsTypeQuery as tSTypeQuery, tsTypeReference as tSTypeReference, tsUndefinedKeyword as tSUndefinedKeyword, tsUnionType as tSUnionType, tsUnknownKeyword as tSUnknownKeyword, tsVoidKeyword as tSVoidKeyword, taggedTemplateExpression, templateElement, templateLiteral, thisExpression, thisTypeAnnotation, throwStatement, toBindingIdentifierName, toBlock, toComputedKey, _default$3 as toExpression, toIdentifier, toKeyAlias, _default$2 as toStatement, topicReference, traverse, traverseFast, tryStatement, tsAnyKeyword, tsArrayType, tsAsExpression, tsBigIntKeyword, tsBooleanKeyword, tsCallSignatureDeclaration, tsConditionalType, tsConstructSignatureDeclaration, tsConstructorType, tsDeclareFunction, tsDeclareMethod, tsEnumBody, tsEnumDeclaration, tsEnumMember, tsExportAssignment, tsExpressionWithTypeArguments, tsExternalModuleReference, tsFunctionType, tsImportEqualsDeclaration, tsImportType, tsIndexSignature, tsIndexedAccessType, tsInferType, tsInstantiationExpression, tsInterfaceBody, tsInterfaceDeclaration, tsIntersectionType, tsIntrinsicKeyword, tsLiteralType, tsMappedType, tsMethodSignature, tsModuleBlock, tsModuleDeclaration, tsNamedTupleMember, tsNamespaceExportDeclaration, tsNeverKeyword, tsNonNullExpression, tsNullKeyword, tsNumberKeyword, tsObjectKeyword, tsOptionalType, tsParameterProperty, tsParenthesizedType, tsPropertySignature, tsQualifiedName, tsRestType, tsSatisfiesExpression, tsStringKeyword, tsSymbolKeyword, tsTemplateLiteralType, tsThisType, tsTupleType, tsTypeAliasDeclaration, tsTypeAnnotation, tsTypeAssertion, tsTypeLiteral, tsTypeOperator, tsTypeParameter, tsTypeParameterDeclaration, tsTypeParameterInstantiation, tsTypePredicate, tsTypeQuery, tsTypeReference, tsUndefinedKeyword, tsUnionType, tsUnknownKeyword, tsVoidKeyword, tupleExpression, tupleTypeAnnotation, typeAlias, typeAnnotation, typeCastExpression, typeParameter, typeParameterDeclaration, typeParameterInstantiation, typeofTypeAnnotation, unaryExpression, unionTypeAnnotation, updateExpression, v8IntrinsicIdentifier, validate, _default$1 as valueToNode, variableDeclaration, variableDeclarator, variance, voidPattern, voidTypeAnnotation, whileStatement, withStatement, yieldExpression };
+export { ACCESSOR_TYPES, ALIAS_KEYS, ASSIGNMENT_OPERATORS, Accessor, Aliases, AnyTypeAnnotation, ArgumentPlaceholder, ArrayExpression, ArrayPattern, ArrayTypeAnnotation, ArrowFunctionExpression, AssignmentExpression, AssignmentPattern, AwaitExpression, BINARY_OPERATORS, BINARY_TYPES, BLOCKPARENT_TYPES, BLOCK_TYPES, BOOLEAN_BINARY_OPERATORS, BOOLEAN_NUMBER_BINARY_OPERATORS, BOOLEAN_UNARY_OPERATORS, BUILDER_KEYS, BigIntLiteral, Binary, BinaryExpression, BindExpression, Block, BlockParent, BlockStatement, BooleanLiteral, BooleanLiteralTypeAnnotation, BooleanTypeAnnotation, BreakStatement, CLASS_TYPES, COMMENT_KEYS, COMPARISON_BINARY_OPERATORS, COMPLETIONSTATEMENT_TYPES, CONDITIONAL_TYPES, CallExpression, CatchClause, Class, ClassAccessorProperty, ClassBody, ClassDeclaration, ClassExpression, ClassImplements, ClassMethod, ClassPrivateMethod, ClassPrivateProperty, ClassProperty, Comment, CommentBlock, CommentLine, CommentTypeShorthand, CompletionStatement, Conditional, ConditionalExpression, ContinueStatement, DECLARATION_TYPES, DEPRECATED_ALIASES, DEPRECATED_KEYS, DebuggerStatement, DecimalLiteral, Declaration, DeclareClass, DeclareExportAllDeclaration, DeclareExportDeclaration, DeclareFunction, DeclareInterface, DeclareModule, DeclareModuleExports, DeclareOpaqueType, DeclareTypeAlias, DeclareVariable, DeclaredPredicate, Decorator, DeprecatedAliases, Directive, DirectiveLiteral, DoExpression, DoWhileStatement, ENUMBODY_TYPES, ENUMMEMBER_TYPES, EQUALITY_BINARY_OPERATORS, EXPORTDECLARATION_TYPES, EXPRESSIONWRAPPER_TYPES, EXPRESSION_TYPES, EmptyStatement, EmptyTypeAnnotation, EnumBody, EnumBooleanBody, EnumBooleanMember, EnumDeclaration, EnumDefaultedMember, EnumMember, EnumNumberBody, EnumNumberMember, EnumStringBody, EnumStringMember, EnumSymbolBody, ExistsTypeAnnotation, ExportAllDeclaration, ExportDeclaration, ExportDefaultDeclaration, ExportDefaultSpecifier, ExportNamedDeclaration, ExportNamespaceSpecifier, ExportSpecifier, Expression, ExpressionStatement, ExpressionWrapper, FLATTENABLE_KEYS, FLIPPED_ALIAS_KEYS, FLOWBASEANNOTATION_TYPES, FLOWDECLARATION_TYPES, FLOWPREDICATE_TYPES, FLOWTYPE_TYPES, FLOW_TYPES, FORXSTATEMENT_TYPES, FOR_INIT_KEYS, FOR_TYPES, FUNCTIONPARAMETER_TYPES, FUNCTIONPARENT_TYPES, FUNCTION_TYPES, FieldOptions, File, Flow, FlowBaseAnnotation, FlowDeclaration, FlowPredicate, FlowType, For, ForInStatement, ForOfStatement, ForStatement, ForXStatement, Function, FunctionDeclaration, FunctionExpression, FunctionParameter, FunctionParent, FunctionTypeAnnotation, FunctionTypeParam, GenericTypeAnnotation, IMMUTABLE_TYPES, IMPORTOREXPORTDECLARATION_TYPES, INHERIT_KEYS, Identifier, IfStatement, Immutable, Import, ImportAttribute, ImportDeclaration, ImportDefaultSpecifier, ImportExpression, ImportNamespaceSpecifier, ImportOrExportDeclaration, ImportSpecifier, IndexedAccessType, InferredPredicate, InterfaceDeclaration, InterfaceExtends, InterfaceTypeAnnotation, InterpreterDirective, IntersectionTypeAnnotation, JSX, JSXAttribute, JSXClosingElement, JSXClosingFragment, JSXElement, JSXEmptyExpression, JSXExpressionContainer, JSXFragment, JSXIdentifier, JSXMemberExpression, JSXNamespacedName, JSXOpeningElement, JSXOpeningFragment, JSXSpreadAttribute, JSXSpreadChild, JSXText, JSX_TYPES, LITERAL_TYPES, LOGICAL_OPERATORS, LOOP_TYPES, LVAL_TYPES, LVal, LabeledStatement, Literal, LogicalExpression, Loop, METHOD_TYPES, MISCELLANEOUS_TYPES, MODULEDECLARATION_TYPES, MODULESPECIFIER_TYPES, MemberExpression, MetaProperty, Method, Miscellaneous, MixedTypeAnnotation, ModuleDeclaration, ModuleExpression, ModuleSpecifier, NODE_FIELDS, NODE_PARENT_VALIDATIONS, NUMBER_BINARY_OPERATORS, NUMBER_UNARY_OPERATORS, NewExpression, Node, Noop, NullLiteral, NullLiteralTypeAnnotation, NullableTypeAnnotation, NumberLiteral$1 as NumberLiteral, NumberLiteralTypeAnnotation, NumberTypeAnnotation, NumericLiteral, OBJECTMEMBER_TYPES, ObjectExpression, ObjectMember, ObjectMethod, ObjectPattern, ObjectProperty, ObjectTypeAnnotation, ObjectTypeCallProperty, ObjectTypeIndexer, ObjectTypeInternalSlot, ObjectTypeProperty, ObjectTypeSpreadProperty, OpaqueType, OptionalCallExpression, OptionalIndexedAccessType, OptionalMemberExpression, PATTERNLIKE_TYPES, PATTERN_TYPES, PLACEHOLDERS, PLACEHOLDERS_ALIAS, PLACEHOLDERS_FLIPPED_ALIAS, PRIVATE_TYPES, PROPERTY_TYPES, PUREISH_TYPES, ParentMaps, ParenthesizedExpression, Pattern, PatternLike, PipelineBareFunction, PipelinePrimaryTopicReference, PipelineTopicExpression, Placeholder, Private, PrivateName, Program, Property, Pureish, QualifiedTypeIdentifier, RecordExpression, RegExpLiteral, RegexLiteral$1 as RegexLiteral, Options$1 as RemovePropertiesOptions, RestElement, RestProperty$1 as RestProperty, ReturnStatement, SCOPABLE_TYPES, STANDARDIZED_TYPES, STATEMENT_OR_BLOCK_KEYS, STATEMENT_TYPES, STRING_UNARY_OPERATORS, Scopable, SequenceExpression, SourceLocation, SpreadElement, SpreadProperty$1 as SpreadProperty, Standardized, Statement, StaticBlock, StringLiteral, StringLiteralTypeAnnotation, StringTypeAnnotation, Super, SwitchCase, SwitchStatement, SymbolTypeAnnotation, TERMINATORLESS_TYPES, TSAnyKeyword, TSArrayType, TSAsExpression, TSBASETYPE_TYPES, TSBaseType, TSBigIntKeyword, TSBooleanKeyword, TSCallSignatureDeclaration, TSConditionalType, TSConstructSignatureDeclaration, TSConstructorType, TSDeclareFunction, TSDeclareMethod, TSENTITYNAME_TYPES, TSEntityName, TSEnumBody, TSEnumDeclaration, TSEnumMember, TSExportAssignment, TSExpressionWithTypeArguments, TSExternalModuleReference, TSFunctionType, TSImportEqualsDeclaration, TSImportType, TSIndexSignature, TSIndexedAccessType, TSInferType, TSInstantiationExpression, TSInterfaceBody, TSInterfaceDeclaration, TSIntersectionType, TSIntrinsicKeyword, TSLiteralType, TSMappedType, TSMethodSignature, TSModuleBlock, TSModuleDeclaration, TSNamedTupleMember, TSNamespaceExportDeclaration, TSNeverKeyword, TSNonNullExpression, TSNullKeyword, TSNumberKeyword, TSObjectKeyword, TSOptionalType, TSParameterProperty, TSParenthesizedType, TSPropertySignature, TSQualifiedName, TSRestType, TSSatisfiesExpression, TSStringKeyword, TSSymbolKeyword, TSTYPEELEMENT_TYPES, TSTYPE_TYPES, TSTemplateLiteralType, TSThisType, TSTupleType, TSType, TSTypeAliasDeclaration, TSTypeAnnotation, TSTypeAssertion, TSTypeElement, TSTypeLiteral, TSTypeOperator, TSTypeParameter, TSTypeParameterDeclaration, TSTypeParameterInstantiation, TSTypePredicate, TSTypeQuery, TSTypeReference, TSUndefinedKeyword, TSUnionType, TSUnknownKeyword, TSVoidKeyword, TYPES, TYPESCRIPT_TYPES, TaggedTemplateExpression, TemplateElement, TemplateLiteral, Terminatorless, ThisExpression, ThisTypeAnnotation, ThrowStatement, TopicReference, TraversalAncestors, TraversalHandler, TraversalHandlers, TryStatement, TupleExpression, TupleTypeAnnotation, TypeAlias, TypeAnnotation, TypeCastExpression, TypeParameter, TypeParameterDeclaration, TypeParameterInstantiation, TypeScript, TypeofTypeAnnotation, UNARYLIKE_TYPES, UNARY_OPERATORS, UPDATE_OPERATORS, USERWHITESPACABLE_TYPES, UnaryExpression, UnaryLike, UnionTypeAnnotation, UpdateExpression, UserWhitespacable, V8IntrinsicIdentifier, VISITOR_KEYS, VariableDeclaration, VariableDeclarator, Variance, VoidPattern, VoidTypeAnnotation, WHILE_TYPES, While, WhileStatement, WithStatement, YieldExpression, deprecationWarning as __internal__deprecationWarning, addComment, addComments, anyTypeAnnotation, appendToMemberExpression, argumentPlaceholder, arrayExpression, arrayPattern, arrayTypeAnnotation, arrowFunctionExpression, assertAccessor, assertAnyTypeAnnotation, assertArgumentPlaceholder, assertArrayExpression, assertArrayPattern, assertArrayTypeAnnotation, assertArrowFunctionExpression, assertAssignmentExpression, assertAssignmentPattern, assertAwaitExpression, assertBigIntLiteral, assertBinary, assertBinaryExpression, assertBindExpression, assertBlock, assertBlockParent, assertBlockStatement, assertBooleanLiteral, assertBooleanLiteralTypeAnnotation, assertBooleanTypeAnnotation, assertBreakStatement, assertCallExpression, assertCatchClause, assertClass, assertClassAccessorProperty, assertClassBody, assertClassDeclaration, assertClassExpression, assertClassImplements, assertClassMethod, assertClassPrivateMethod, assertClassPrivateProperty, assertClassProperty, assertCompletionStatement, assertConditional, assertConditionalExpression, assertContinueStatement, assertDebuggerStatement, assertDecimalLiteral, assertDeclaration, assertDeclareClass, assertDeclareExportAllDeclaration, assertDeclareExportDeclaration, assertDeclareFunction, assertDeclareInterface, assertDeclareModule, assertDeclareModuleExports, assertDeclareOpaqueType, assertDeclareTypeAlias, assertDeclareVariable, assertDeclaredPredicate, assertDecorator, assertDirective, assertDirectiveLiteral, assertDoExpression, assertDoWhileStatement, assertEmptyStatement, assertEmptyTypeAnnotation, assertEnumBody, assertEnumBooleanBody, assertEnumBooleanMember, assertEnumDeclaration, assertEnumDefaultedMember, assertEnumMember, assertEnumNumberBody, assertEnumNumberMember, assertEnumStringBody, assertEnumStringMember, assertEnumSymbolBody, assertExistsTypeAnnotation, assertExportAllDeclaration, assertExportDeclaration, assertExportDefaultDeclaration, assertExportDefaultSpecifier, assertExportNamedDeclaration, assertExportNamespaceSpecifier, assertExportSpecifier, assertExpression, assertExpressionStatement, assertExpressionWrapper, assertFile, assertFlow, assertFlowBaseAnnotation, assertFlowDeclaration, assertFlowPredicate, assertFlowType, assertFor, assertForInStatement, assertForOfStatement, assertForStatement, assertForXStatement, assertFunction, assertFunctionDeclaration, assertFunctionExpression, assertFunctionParameter, assertFunctionParent, assertFunctionTypeAnnotation, assertFunctionTypeParam, assertGenericTypeAnnotation, assertIdentifier, assertIfStatement, assertImmutable, assertImport, assertImportAttribute, assertImportDeclaration, assertImportDefaultSpecifier, assertImportExpression, assertImportNamespaceSpecifier, assertImportOrExportDeclaration, assertImportSpecifier, assertIndexedAccessType, assertInferredPredicate, assertInterfaceDeclaration, assertInterfaceExtends, assertInterfaceTypeAnnotation, assertInterpreterDirective, assertIntersectionTypeAnnotation, assertJSX, assertJSXAttribute, assertJSXClosingElement, assertJSXClosingFragment, assertJSXElement, assertJSXEmptyExpression, assertJSXExpressionContainer, assertJSXFragment, assertJSXIdentifier, assertJSXMemberExpression, assertJSXNamespacedName, assertJSXOpeningElement, assertJSXOpeningFragment, assertJSXSpreadAttribute, assertJSXSpreadChild, assertJSXText, assertLVal, assertLabeledStatement, assertLiteral, assertLogicalExpression, assertLoop, assertMemberExpression, assertMetaProperty, assertMethod, assertMiscellaneous, assertMixedTypeAnnotation, assertModuleDeclaration, assertModuleExpression, assertModuleSpecifier, assertNewExpression, assertNode, assertNoop, assertNullLiteral, assertNullLiteralTypeAnnotation, assertNullableTypeAnnotation, assertNumberLiteral, assertNumberLiteralTypeAnnotation, assertNumberTypeAnnotation, assertNumericLiteral, assertObjectExpression, assertObjectMember, assertObjectMethod, assertObjectPattern, assertObjectProperty, assertObjectTypeAnnotation, assertObjectTypeCallProperty, assertObjectTypeIndexer, assertObjectTypeInternalSlot, assertObjectTypeProperty, assertObjectTypeSpreadProperty, assertOpaqueType, assertOptionalCallExpression, assertOptionalIndexedAccessType, assertOptionalMemberExpression, assertParenthesizedExpression, assertPattern, assertPatternLike, assertPipelineBareFunction, assertPipelinePrimaryTopicReference, assertPipelineTopicExpression, assertPlaceholder, assertPrivate, assertPrivateName, assertProgram, assertProperty, assertPureish, assertQualifiedTypeIdentifier, assertRecordExpression, assertRegExpLiteral, assertRegexLiteral, assertRestElement, assertRestProperty, assertReturnStatement, assertScopable, assertSequenceExpression, assertSpreadElement, assertSpreadProperty, assertStandardized, assertStatement, assertStaticBlock, assertStringLiteral, assertStringLiteralTypeAnnotation, assertStringTypeAnnotation, assertSuper, assertSwitchCase, assertSwitchStatement, assertSymbolTypeAnnotation, assertTSAnyKeyword, assertTSArrayType, assertTSAsExpression, assertTSBaseType, assertTSBigIntKeyword, assertTSBooleanKeyword, assertTSCallSignatureDeclaration, assertTSConditionalType, assertTSConstructSignatureDeclaration, assertTSConstructorType, assertTSDeclareFunction, assertTSDeclareMethod, assertTSEntityName, assertTSEnumBody, assertTSEnumDeclaration, assertTSEnumMember, assertTSExportAssignment, assertTSExpressionWithTypeArguments, assertTSExternalModuleReference, assertTSFunctionType, assertTSImportEqualsDeclaration, assertTSImportType, assertTSIndexSignature, assertTSIndexedAccessType, assertTSInferType, assertTSInstantiationExpression, assertTSInterfaceBody, assertTSInterfaceDeclaration, assertTSIntersectionType, assertTSIntrinsicKeyword, assertTSLiteralType, assertTSMappedType, assertTSMethodSignature, assertTSModuleBlock, assertTSModuleDeclaration, assertTSNamedTupleMember, assertTSNamespaceExportDeclaration, assertTSNeverKeyword, assertTSNonNullExpression, assertTSNullKeyword, assertTSNumberKeyword, assertTSObjectKeyword, assertTSOptionalType, assertTSParameterProperty, assertTSParenthesizedType, assertTSPropertySignature, assertTSQualifiedName, assertTSRestType, assertTSSatisfiesExpression, assertTSStringKeyword, assertTSSymbolKeyword, assertTSTemplateLiteralType, assertTSThisType, assertTSTupleType, assertTSType, assertTSTypeAliasDeclaration, assertTSTypeAnnotation, assertTSTypeAssertion, assertTSTypeElement, assertTSTypeLiteral, assertTSTypeOperator, assertTSTypeParameter, assertTSTypeParameterDeclaration, assertTSTypeParameterInstantiation, assertTSTypePredicate, assertTSTypeQuery, assertTSTypeReference, assertTSUndefinedKeyword, assertTSUnionType, assertTSUnknownKeyword, assertTSVoidKeyword, assertTaggedTemplateExpression, assertTemplateElement, assertTemplateLiteral, assertTerminatorless, assertThisExpression, assertThisTypeAnnotation, assertThrowStatement, assertTopicReference, assertTryStatement, assertTupleExpression, assertTupleTypeAnnotation, assertTypeAlias, assertTypeAnnotation, assertTypeCastExpression, assertTypeParameter, assertTypeParameterDeclaration, assertTypeParameterInstantiation, assertTypeScript, assertTypeofTypeAnnotation, assertUnaryExpression, assertUnaryLike, assertUnionTypeAnnotation, assertUpdateExpression, assertUserWhitespacable, assertV8IntrinsicIdentifier, assertVariableDeclaration, assertVariableDeclarator, assertVariance, assertVoidPattern, assertVoidTypeAnnotation, assertWhile, assertWhileStatement, assertWithStatement, assertYieldExpression, assignmentExpression, assignmentPattern, awaitExpression, bigIntLiteral, binaryExpression, bindExpression, blockStatement, booleanLiteral, booleanLiteralTypeAnnotation, booleanTypeAnnotation, breakStatement, buildMatchMemberExpression, buildUndefinedNode, callExpression, catchClause, classAccessorProperty, classBody, classDeclaration, classExpression, classImplements, classMethod, classPrivateMethod, classPrivateProperty, classProperty, clone, cloneDeep, cloneDeepWithoutLoc, cloneNode, cloneWithoutLoc, conditionalExpression, continueStatement, createFlowUnionType, createTSUnionType, _default$4 as createTypeAnnotationBasedOnTypeof, createFlowUnionType as createUnionTypeAnnotation, debuggerStatement, decimalLiteral, declareClass, declareExportAllDeclaration, declareExportDeclaration, declareFunction, declareInterface, declareModule, declareModuleExports, declareOpaqueType, declareTypeAlias, declareVariable, declaredPredicate, decorator, directive, directiveLiteral, doExpression, doWhileStatement, emptyStatement, emptyTypeAnnotation, ensureBlock, enumBooleanBody, enumBooleanMember, enumDeclaration, enumDefaultedMember, enumNumberBody, enumNumberMember, enumStringBody, enumStringMember, enumSymbolBody, existsTypeAnnotation, exportAllDeclaration, exportDefaultDeclaration, exportDefaultSpecifier, exportNamedDeclaration, exportNamespaceSpecifier, exportSpecifier, expressionStatement, file, forInStatement, forOfStatement, forStatement, functionDeclaration, functionExpression, functionTypeAnnotation, functionTypeParam, genericTypeAnnotation, getAssignmentIdentifiers, getBindingIdentifiers, getFunctionName, _default as getOuterBindingIdentifiers, identifier, ifStatement, _import as import, importAttribute, importDeclaration, importDefaultSpecifier, importExpression, importNamespaceSpecifier, importSpecifier, indexedAccessType, inferredPredicate, inheritInnerComments, inheritLeadingComments, inheritTrailingComments, inherits, inheritsComments, interfaceDeclaration, interfaceExtends, interfaceTypeAnnotation, interpreterDirective, intersectionTypeAnnotation, is, isAccessor, isAnyTypeAnnotation, isArgumentPlaceholder, isArrayExpression, isArrayPattern, isArrayTypeAnnotation, isArrowFunctionExpression, isAssignmentExpression, isAssignmentPattern, isAwaitExpression, isBigIntLiteral, isBinary, isBinaryExpression, isBindExpression, isBinding, isBlock, isBlockParent, isBlockScoped, isBlockStatement, isBooleanLiteral, isBooleanLiteralTypeAnnotation, isBooleanTypeAnnotation, isBreakStatement, isCallExpression, isCatchClause, isClass, isClassAccessorProperty, isClassBody, isClassDeclaration, isClassExpression, isClassImplements, isClassMethod, isClassPrivateMethod, isClassPrivateProperty, isClassProperty, isCompletionStatement, isConditional, isConditionalExpression, isContinueStatement, isDebuggerStatement, isDecimalLiteral, isDeclaration, isDeclareClass, isDeclareExportAllDeclaration, isDeclareExportDeclaration, isDeclareFunction, isDeclareInterface, isDeclareModule, isDeclareModuleExports, isDeclareOpaqueType, isDeclareTypeAlias, isDeclareVariable, isDeclaredPredicate, isDecorator, isDirective, isDirectiveLiteral, isDoExpression, isDoWhileStatement, isEmptyStatement, isEmptyTypeAnnotation, isEnumBody, isEnumBooleanBody, isEnumBooleanMember, isEnumDeclaration, isEnumDefaultedMember, isEnumMember, isEnumNumberBody, isEnumNumberMember, isEnumStringBody, isEnumStringMember, isEnumSymbolBody, isExistsTypeAnnotation, isExportAllDeclaration, isExportDeclaration, isExportDefaultDeclaration, isExportDefaultSpecifier, isExportNamedDeclaration, isExportNamespaceSpecifier, isExportSpecifier, isExpression, isExpressionStatement, isExpressionWrapper, isFile, isFlow, isFlowBaseAnnotation, isFlowDeclaration, isFlowPredicate, isFlowType, isFor, isForInStatement, isForOfStatement, isForStatement, isForXStatement, isFunction, isFunctionDeclaration, isFunctionExpression, isFunctionParameter, isFunctionParent, isFunctionTypeAnnotation, isFunctionTypeParam, isGenericTypeAnnotation, isIdentifier, isIfStatement, isImmutable, isImport, isImportAttribute, isImportDeclaration, isImportDefaultSpecifier, isImportExpression, isImportNamespaceSpecifier, isImportOrExportDeclaration, isImportSpecifier, isIndexedAccessType, isInferredPredicate, isInterfaceDeclaration, isInterfaceExtends, isInterfaceTypeAnnotation, isInterpreterDirective, isIntersectionTypeAnnotation, isJSX, isJSXAttribute, isJSXClosingElement, isJSXClosingFragment, isJSXElement, isJSXEmptyExpression, isJSXExpressionContainer, isJSXFragment, isJSXIdentifier, isJSXMemberExpression, isJSXNamespacedName, isJSXOpeningElement, isJSXOpeningFragment, isJSXSpreadAttribute, isJSXSpreadChild, isJSXText, isLVal, isLabeledStatement, isLet, isLiteral, isLogicalExpression, isLoop, isMemberExpression, isMetaProperty, isMethod, isMiscellaneous, isMixedTypeAnnotation, isModuleDeclaration, isModuleExpression, isModuleSpecifier, isNewExpression, isNode, isNodesEquivalent, isNoop, isNullLiteral, isNullLiteralTypeAnnotation, isNullableTypeAnnotation, isNumberLiteral, isNumberLiteralTypeAnnotation, isNumberTypeAnnotation, isNumericLiteral, isObjectExpression, isObjectMember, isObjectMethod, isObjectPattern, isObjectProperty, isObjectTypeAnnotation, isObjectTypeCallProperty, isObjectTypeIndexer, isObjectTypeInternalSlot, isObjectTypeProperty, isObjectTypeSpreadProperty, isOpaqueType, isOptionalCallExpression, isOptionalIndexedAccessType, isOptionalMemberExpression, isParenthesizedExpression, isPattern, isPatternLike, isPipelineBareFunction, isPipelinePrimaryTopicReference, isPipelineTopicExpression, isPlaceholder, isPlaceholderType, isPrivate, isPrivateName, isProgram, isProperty, isPureish, isQualifiedTypeIdentifier, isRecordExpression, isReferenced, isRegExpLiteral, isRegexLiteral, isRestElement, isRestProperty, isReturnStatement, isScopable, isScope, isSequenceExpression, isSpecifierDefault, isSpreadElement, isSpreadProperty, isStandardized, isStatement, isStaticBlock, isStringLiteral, isStringLiteralTypeAnnotation, isStringTypeAnnotation, isSuper, isSwitchCase, isSwitchStatement, isSymbolTypeAnnotation, isTSAnyKeyword, isTSArrayType, isTSAsExpression, isTSBaseType, isTSBigIntKeyword, isTSBooleanKeyword, isTSCallSignatureDeclaration, isTSConditionalType, isTSConstructSignatureDeclaration, isTSConstructorType, isTSDeclareFunction, isTSDeclareMethod, isTSEntityName, isTSEnumBody, isTSEnumDeclaration, isTSEnumMember, isTSExportAssignment, isTSExpressionWithTypeArguments, isTSExternalModuleReference, isTSFunctionType, isTSImportEqualsDeclaration, isTSImportType, isTSIndexSignature, isTSIndexedAccessType, isTSInferType, isTSInstantiationExpression, isTSInterfaceBody, isTSInterfaceDeclaration, isTSIntersectionType, isTSIntrinsicKeyword, isTSLiteralType, isTSMappedType, isTSMethodSignature, isTSModuleBlock, isTSModuleDeclaration, isTSNamedTupleMember, isTSNamespaceExportDeclaration, isTSNeverKeyword, isTSNonNullExpression, isTSNullKeyword, isTSNumberKeyword, isTSObjectKeyword, isTSOptionalType, isTSParameterProperty, isTSParenthesizedType, isTSPropertySignature, isTSQualifiedName, isTSRestType, isTSSatisfiesExpression, isTSStringKeyword, isTSSymbolKeyword, isTSTemplateLiteralType, isTSThisType, isTSTupleType, isTSType, isTSTypeAliasDeclaration, isTSTypeAnnotation, isTSTypeAssertion, isTSTypeElement, isTSTypeLiteral, isTSTypeOperator, isTSTypeParameter, isTSTypeParameterDeclaration, isTSTypeParameterInstantiation, isTSTypePredicate, isTSTypeQuery, isTSTypeReference, isTSUndefinedKeyword, isTSUnionType, isTSUnknownKeyword, isTSVoidKeyword, isTaggedTemplateExpression, isTemplateElement, isTemplateLiteral, isTerminatorless, isThisExpression, isThisTypeAnnotation, isThrowStatement, isTopicReference, isTryStatement, isTupleExpression, isTupleTypeAnnotation, isType, isTypeAlias, isTypeAnnotation, isTypeCastExpression, isTypeParameter, isTypeParameterDeclaration, isTypeParameterInstantiation, isTypeScript, isTypeofTypeAnnotation, isUnaryExpression, isUnaryLike, isUnionTypeAnnotation, isUpdateExpression, isUserWhitespacable, isV8IntrinsicIdentifier, isValidES3Identifier, isValidIdentifier, isVar, isVariableDeclaration, isVariableDeclarator, isVariance, isVoidPattern, isVoidTypeAnnotation, isWhile, isWhileStatement, isWithStatement, isYieldExpression, jsxAttribute as jSXAttribute, jsxClosingElement as jSXClosingElement, jsxClosingFragment as jSXClosingFragment, jsxElement as jSXElement, jsxEmptyExpression as jSXEmptyExpression, jsxExpressionContainer as jSXExpressionContainer, jsxFragment as jSXFragment, jsxIdentifier as jSXIdentifier, jsxMemberExpression as jSXMemberExpression, jsxNamespacedName as jSXNamespacedName, jsxOpeningElement as jSXOpeningElement, jsxOpeningFragment as jSXOpeningFragment, jsxSpreadAttribute as jSXSpreadAttribute, jsxSpreadChild as jSXSpreadChild, jsxText as jSXText, jsxAttribute, jsxClosingElement, jsxClosingFragment, jsxElement, jsxEmptyExpression, jsxExpressionContainer, jsxFragment, jsxIdentifier, jsxMemberExpression, jsxNamespacedName, jsxOpeningElement, jsxOpeningFragment, jsxSpreadAttribute, jsxSpreadChild, jsxText, labeledStatement, logicalExpression, matchesPattern, memberExpression, metaProperty, mixedTypeAnnotation, moduleExpression, newExpression, noop, nullLiteral, nullLiteralTypeAnnotation, nullableTypeAnnotation, NumberLiteral as numberLiteral, numberLiteralTypeAnnotation, numberTypeAnnotation, numericLiteral, objectExpression, objectMethod, objectPattern, objectProperty, objectTypeAnnotation, objectTypeCallProperty, objectTypeIndexer, objectTypeInternalSlot, objectTypeProperty, objectTypeSpreadProperty, opaqueType, optionalCallExpression, optionalIndexedAccessType, optionalMemberExpression, parenthesizedExpression, pipelineBareFunction, pipelinePrimaryTopicReference, pipelineTopicExpression, placeholder, prependToMemberExpression, privateName, program, qualifiedTypeIdentifier, react, recordExpression, regExpLiteral, RegexLiteral as regexLiteral, removeComments, removeProperties, removePropertiesDeep, removeTypeDuplicates, restElement, RestProperty as restProperty, returnStatement, sequenceExpression, shallowEqual, spreadElement, SpreadProperty as spreadProperty, staticBlock, stringLiteral, stringLiteralTypeAnnotation, stringTypeAnnotation, _super as super, switchCase, switchStatement, symbolTypeAnnotation, tsAnyKeyword as tSAnyKeyword, tsArrayType as tSArrayType, tsAsExpression as tSAsExpression, tsBigIntKeyword as tSBigIntKeyword, tsBooleanKeyword as tSBooleanKeyword, tsCallSignatureDeclaration as tSCallSignatureDeclaration, tsConditionalType as tSConditionalType, tsConstructSignatureDeclaration as tSConstructSignatureDeclaration, tsConstructorType as tSConstructorType, tsDeclareFunction as tSDeclareFunction, tsDeclareMethod as tSDeclareMethod, tsEnumBody as tSEnumBody, tsEnumDeclaration as tSEnumDeclaration, tsEnumMember as tSEnumMember, tsExportAssignment as tSExportAssignment, tsExpressionWithTypeArguments as tSExpressionWithTypeArguments, tsExternalModuleReference as tSExternalModuleReference, tsFunctionType as tSFunctionType, tsImportEqualsDeclaration as tSImportEqualsDeclaration, tsImportType as tSImportType, tsIndexSignature as tSIndexSignature, tsIndexedAccessType as tSIndexedAccessType, tsInferType as tSInferType, tsInstantiationExpression as tSInstantiationExpression, tsInterfaceBody as tSInterfaceBody, tsInterfaceDeclaration as tSInterfaceDeclaration, tsIntersectionType as tSIntersectionType, tsIntrinsicKeyword as tSIntrinsicKeyword, tsLiteralType as tSLiteralType, tsMappedType as tSMappedType, tsMethodSignature as tSMethodSignature, tsModuleBlock as tSModuleBlock, tsModuleDeclaration as tSModuleDeclaration, tsNamedTupleMember as tSNamedTupleMember, tsNamespaceExportDeclaration as tSNamespaceExportDeclaration, tsNeverKeyword as tSNeverKeyword, tsNonNullExpression as tSNonNullExpression, tsNullKeyword as tSNullKeyword, tsNumberKeyword as tSNumberKeyword, tsObjectKeyword as tSObjectKeyword, tsOptionalType as tSOptionalType, tsParameterProperty as tSParameterProperty, tsParenthesizedType as tSParenthesizedType, tsPropertySignature as tSPropertySignature, tsQualifiedName as tSQualifiedName, tsRestType as tSRestType, tsSatisfiesExpression as tSSatisfiesExpression, tsStringKeyword as tSStringKeyword, tsSymbolKeyword as tSSymbolKeyword, tsTemplateLiteralType as tSTemplateLiteralType, tsThisType as tSThisType, tsTupleType as tSTupleType, tsTypeAliasDeclaration as tSTypeAliasDeclaration, tsTypeAnnotation as tSTypeAnnotation, tsTypeAssertion as tSTypeAssertion, tsTypeLiteral as tSTypeLiteral, tsTypeOperator as tSTypeOperator, tsTypeParameter as tSTypeParameter, tsTypeParameterDeclaration as tSTypeParameterDeclaration, tsTypeParameterInstantiation as tSTypeParameterInstantiation, tsTypePredicate as tSTypePredicate, tsTypeQuery as tSTypeQuery, tsTypeReference as tSTypeReference, tsUndefinedKeyword as tSUndefinedKeyword, tsUnionType as tSUnionType, tsUnknownKeyword as tSUnknownKeyword, tsVoidKeyword as tSVoidKeyword, taggedTemplateExpression, templateElement, templateLiteral, thisExpression, thisTypeAnnotation, throwStatement, toBindingIdentifierName, toBlock, toComputedKey, _default$3 as toExpression, toIdentifier, toKeyAlias, _default$2 as toStatement, topicReference, traverse, traverseFast, tryStatement, tsAnyKeyword, tsArrayType, tsAsExpression, tsBigIntKeyword, tsBooleanKeyword, tsCallSignatureDeclaration, tsConditionalType, tsConstructSignatureDeclaration, tsConstructorType, tsDeclareFunction, tsDeclareMethod, tsEnumBody, tsEnumDeclaration, tsEnumMember, tsExportAssignment, tsExpressionWithTypeArguments, tsExternalModuleReference, tsFunctionType, tsImportEqualsDeclaration, tsImportType, tsIndexSignature, tsIndexedAccessType, tsInferType, tsInstantiationExpression, tsInterfaceBody, tsInterfaceDeclaration, tsIntersectionType, tsIntrinsicKeyword, tsLiteralType, tsMappedType, tsMethodSignature, tsModuleBlock, tsModuleDeclaration, tsNamedTupleMember, tsNamespaceExportDeclaration, tsNeverKeyword, tsNonNullExpression, tsNullKeyword, tsNumberKeyword, tsObjectKeyword, tsOptionalType, tsParameterProperty, tsParenthesizedType, tsPropertySignature, tsQualifiedName, tsRestType, tsSatisfiesExpression, tsStringKeyword, tsSymbolKeyword, tsTemplateLiteralType, tsThisType, tsTupleType, tsTypeAliasDeclaration, tsTypeAnnotation, tsTypeAssertion, tsTypeLiteral, tsTypeOperator, tsTypeParameter, tsTypeParameterDeclaration, tsTypeParameterInstantiation, tsTypePredicate, tsTypeQuery, tsTypeReference, tsUndefinedKeyword, tsUnionType, tsUnknownKeyword, tsVoidKeyword, tupleExpression, tupleTypeAnnotation, typeAlias, typeAnnotation, typeCastExpression, typeParameter, typeParameterDeclaration, typeParameterInstantiation, typeofTypeAnnotation, unaryExpression, unionTypeAnnotation, updateExpression, v8IntrinsicIdentifier, validate, _default$1 as valueToNode, variableDeclaration, variableDeclarator, variance, voidPattern, voidTypeAnnotation, whileStatement, withStatement, yieldExpression };