storybook 9.1.13 → 9.1.15

package/dist/babel/index.d.ts

@@ -350,7 +350,7 @@ interface BaseComment {
     ignore?: boolean;
     type: "CommentBlock" | "CommentLine";
 }
-interface Position {
+interface Position$1 {
     line: number;
     column: number;
     index: number;
@@ -363,13 +363,12 @@ interface CommentLine extends BaseComment {
 }
 type Comment = CommentBlock | CommentLine;
 interface SourceLocation {
-    start: Position;
-    end: Position;
+    start: Position$1;
+    end: Position$1;
     filename: string;
     identifierName: string | undefined | null;
 }
 interface BaseNode {
-    type: Node$1["type"];
     leadingComments?: Comment[] | null;
     innerComments?: Comment[] | null;
     trailingComments?: Comment[] | null;
@@ -2461,7 +2460,7 @@ 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;
 
@@ -2738,25 +2737,33 @@ type PrimitiveTypes = ReturnType<typeof getType>;
 type FieldDefinitions = {
     [x: string]: FieldOptions;
 };
-type Validator = ({
+type ValidatorImpl = (node?: Node$1, 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)[];
-} | {
+} & 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: {
         [x: string]: FieldOptions;
     };
-} | object) & ((node: Node$1, key: string | {
-    toString(): string;
-}, val: any) => void);
+} & ValidatorImpl;
+type Validator = ValidatorType | ValidatorEach | ValidatorChainOf | ValidatorOneOf | ValidatorOneOfNodeTypes | ValidatorOneOfNodeOrValueTypes | ValidatorShapeOf | ValidatorImpl;
 type FieldOptions = {
     default?: string | number | boolean | [];
     optional?: boolean;
@@ -2895,7 +2902,7 @@ declare function isBinding(node: Node$1, parent: Node$1, grandparent?: Node$1):
 /**
  * Check if the input `node` is block scoped.
  */
-declare function isBlockScoped(node: Node$1): boolean;
+declare function isBlockScoped(node: Node$1 | null | undefined): boolean;
 
 /**
  * Check if the input `node` is definitely immutable.
@@ -2922,12 +2929,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$1, parent: Node$1, grandparent?: Node$1): boolean;
+declare function isReferenced(node: Node$1 | null | undefined, parent: Node$1, grandparent?: Node$1): boolean;
 
 /**
  * Check if the input `node` is a scope.
  */
-declare function isScope(node: Node$1, parent: Node$1): boolean;
+declare function isScope(node: Node$1 | null | undefined, parent: Node$1): boolean;
 
 /**
  * Check if the input `specifier` is a `default` import or export.
@@ -2953,7 +2960,7 @@ declare function isValidIdentifier(name: string, reserved?: boolean): boolean;
 /**
  * Check if the input `node` is a variable declaration.
  */
-declare function isVar(node: Node$1): boolean;
+declare function isVar(node: Node$1 | null | undefined): boolean;
 
 /**
  * Determines whether or not the input node `member` matches the
@@ -2975,331 +2982,637 @@ declare function validate(node: Node$1 | undefined | null, key: string, val: unk
  */
 declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (member: Node$1) => boolean;
 
-type Opts<Obj> = Partial<{
-    [Prop in keyof Obj]: Obj[Prop] extends Node$1 ? Node$1 : Obj[Prop] extends Node$1[] ? Node$1[] : Obj[Prop];
+type Options$2<Obj> = Partial<{
+    [Prop in Exclude<keyof Obj, "type">]: Obj[Prop] extends Node$1 ? Node$1 : Obj[Prop] extends Node$1[] ? Node$1[] : Obj[Prop];
 }>;
-declare function isArrayExpression(node: Node$1 | null | undefined, opts?: Opts<ArrayExpression> | null): node is ArrayExpression;
-declare function isAssignmentExpression(node: Node$1 | null | undefined, opts?: Opts<AssignmentExpression> | null): node is AssignmentExpression;
-declare function isBinaryExpression(node: Node$1 | null | undefined, opts?: Opts<BinaryExpression> | null): node is BinaryExpression;
-declare function isInterpreterDirective(node: Node$1 | null | undefined, opts?: Opts<InterpreterDirective> | null): node is InterpreterDirective;
-declare function isDirective(node: Node$1 | null | undefined, opts?: Opts<Directive> | null): node is Directive;
-declare function isDirectiveLiteral(node: Node$1 | null | undefined, opts?: Opts<DirectiveLiteral> | null): node is DirectiveLiteral;
-declare function isBlockStatement(node: Node$1 | null | undefined, opts?: Opts<BlockStatement> | null): node is BlockStatement;
-declare function isBreakStatement(node: Node$1 | null | undefined, opts?: Opts<BreakStatement> | null): node is BreakStatement;
-declare function isCallExpression(node: Node$1 | null | undefined, opts?: Opts<CallExpression> | null): node is CallExpression;
-declare function isCatchClause(node: Node$1 | null | undefined, opts?: Opts<CatchClause> | null): node is CatchClause;
-declare function isConditionalExpression(node: Node$1 | null | undefined, opts?: Opts<ConditionalExpression> | null): node is ConditionalExpression;
-declare function isContinueStatement(node: Node$1 | null | undefined, opts?: Opts<ContinueStatement> | null): node is ContinueStatement;
-declare function isDebuggerStatement(node: Node$1 | null | undefined, opts?: Opts<DebuggerStatement> | null): node is DebuggerStatement;
-declare function isDoWhileStatement(node: Node$1 | null | undefined, opts?: Opts<DoWhileStatement> | null): node is DoWhileStatement;
-declare function isEmptyStatement(node: Node$1 | null | undefined, opts?: Opts<EmptyStatement> | null): node is EmptyStatement;
-declare function isExpressionStatement(node: Node$1 | null | undefined, opts?: Opts<ExpressionStatement> | null): node is ExpressionStatement;
-declare function isFile(node: Node$1 | null | undefined, opts?: Opts<File> | null): node is File;
-declare function isForInStatement(node: Node$1 | null | undefined, opts?: Opts<ForInStatement> | null): node is ForInStatement;
-declare function isForStatement(node: Node$1 | null | undefined, opts?: Opts<ForStatement> | null): node is ForStatement;
-declare function isFunctionDeclaration(node: Node$1 | null | undefined, opts?: Opts<FunctionDeclaration> | null): node is FunctionDeclaration;
-declare function isFunctionExpression(node: Node$1 | null | undefined, opts?: Opts<FunctionExpression> | null): node is FunctionExpression;
-declare function isIdentifier(node: Node$1 | null | undefined, opts?: Opts<Identifier> | null): node is Identifier;
-declare function isIfStatement(node: Node$1 | null | undefined, opts?: Opts<IfStatement> | null): node is IfStatement;
-declare function isLabeledStatement(node: Node$1 | null | undefined, opts?: Opts<LabeledStatement> | null): node is LabeledStatement;
-declare function isStringLiteral(node: Node$1 | null | undefined, opts?: Opts<StringLiteral> | null): node is StringLiteral;
-declare function isNumericLiteral(node: Node$1 | null | undefined, opts?: Opts<NumericLiteral> | null): node is NumericLiteral;
-declare function isNullLiteral(node: Node$1 | null | undefined, opts?: Opts<NullLiteral> | null): node is NullLiteral;
-declare function isBooleanLiteral(node: Node$1 | null | undefined, opts?: Opts<BooleanLiteral> | null): node is BooleanLiteral;
-declare function isRegExpLiteral(node: Node$1 | null | undefined, opts?: Opts<RegExpLiteral> | null): node is RegExpLiteral;
-declare function isLogicalExpression(node: Node$1 | null | undefined, opts?: Opts<LogicalExpression> | null): node is LogicalExpression;
-declare function isMemberExpression(node: Node$1 | null | undefined, opts?: Opts<MemberExpression> | null): node is MemberExpression;
-declare function isNewExpression(node: Node$1 | null | undefined, opts?: Opts<NewExpression> | null): node is NewExpression;
-declare function isProgram(node: Node$1 | null | undefined, opts?: Opts<Program> | null): node is Program;
-declare function isObjectExpression(node: Node$1 | null | undefined, opts?: Opts<ObjectExpression> | null): node is ObjectExpression;
-declare function isObjectMethod(node: Node$1 | null | undefined, opts?: Opts<ObjectMethod> | null): node is ObjectMethod;
-declare function isObjectProperty(node: Node$1 | null | undefined, opts?: Opts<ObjectProperty> | null): node is ObjectProperty;
-declare function isRestElement(node: Node$1 | null | undefined, opts?: Opts<RestElement> | null): node is RestElement;
-declare function isReturnStatement(node: Node$1 | null | undefined, opts?: Opts<ReturnStatement> | null): node is ReturnStatement;
-declare function isSequenceExpression(node: Node$1 | null | undefined, opts?: Opts<SequenceExpression> | null): node is SequenceExpression;
-declare function isParenthesizedExpression(node: Node$1 | null | undefined, opts?: Opts<ParenthesizedExpression> | null): node is ParenthesizedExpression;
-declare function isSwitchCase(node: Node$1 | null | undefined, opts?: Opts<SwitchCase> | null): node is SwitchCase;
-declare function isSwitchStatement(node: Node$1 | null | undefined, opts?: Opts<SwitchStatement> | null): node is SwitchStatement;
-declare function isThisExpression(node: Node$1 | null | undefined, opts?: Opts<ThisExpression> | null): node is ThisExpression;
-declare function isThrowStatement(node: Node$1 | null | undefined, opts?: Opts<ThrowStatement> | null): node is ThrowStatement;
-declare function isTryStatement(node: Node$1 | null | undefined, opts?: Opts<TryStatement> | null): node is TryStatement;
-declare function isUnaryExpression(node: Node$1 | null | undefined, opts?: Opts<UnaryExpression> | null): node is UnaryExpression;
-declare function isUpdateExpression(node: Node$1 | null | undefined, opts?: Opts<UpdateExpression> | null): node is UpdateExpression;
-declare function isVariableDeclaration(node: Node$1 | null | undefined, opts?: Opts<VariableDeclaration> | null): node is VariableDeclaration;
-declare function isVariableDeclarator(node: Node$1 | null | undefined, opts?: Opts<VariableDeclarator> | null): node is VariableDeclarator;
-declare function isWhileStatement(node: Node$1 | null | undefined, opts?: Opts<WhileStatement> | null): node is WhileStatement;
-declare function isWithStatement(node: Node$1 | null | undefined, opts?: Opts<WithStatement> | null): node is WithStatement;
-declare function isAssignmentPattern(node: Node$1 | null | undefined, opts?: Opts<AssignmentPattern> | null): node is AssignmentPattern;
-declare function isArrayPattern(node: Node$1 | null | undefined, opts?: Opts<ArrayPattern> | null): node is ArrayPattern;
-declare function isArrowFunctionExpression(node: Node$1 | null | undefined, opts?: Opts<ArrowFunctionExpression> | null): node is ArrowFunctionExpression;
-declare function isClassBody(node: Node$1 | null | undefined, opts?: Opts<ClassBody> | null): node is ClassBody;
-declare function isClassExpression(node: Node$1 | null | undefined, opts?: Opts<ClassExpression> | null): node is ClassExpression;
-declare function isClassDeclaration(node: Node$1 | null | undefined, opts?: Opts<ClassDeclaration> | null): node is ClassDeclaration;
-declare function isExportAllDeclaration(node: Node$1 | null | undefined, opts?: Opts<ExportAllDeclaration> | null): node is ExportAllDeclaration;
-declare function isExportDefaultDeclaration(node: Node$1 | null | undefined, opts?: Opts<ExportDefaultDeclaration> | null): node is ExportDefaultDeclaration;
-declare function isExportNamedDeclaration(node: Node$1 | null | undefined, opts?: Opts<ExportNamedDeclaration> | null): node is ExportNamedDeclaration;
-declare function isExportSpecifier(node: Node$1 | null | undefined, opts?: Opts<ExportSpecifier> | null): node is ExportSpecifier;
-declare function isForOfStatement(node: Node$1 | null | undefined, opts?: Opts<ForOfStatement> | null): node is ForOfStatement;
-declare function isImportDeclaration(node: Node$1 | null | undefined, opts?: Opts<ImportDeclaration> | null): node is ImportDeclaration;
-declare function isImportDefaultSpecifier(node: Node$1 | null | undefined, opts?: Opts<ImportDefaultSpecifier> | null): node is ImportDefaultSpecifier;
-declare function isImportNamespaceSpecifier(node: Node$1 | null | undefined, opts?: Opts<ImportNamespaceSpecifier> | null): node is ImportNamespaceSpecifier;
-declare function isImportSpecifier(node: Node$1 | null | undefined, opts?: Opts<ImportSpecifier> | null): node is ImportSpecifier;
-declare function isImportExpression(node: Node$1 | null | undefined, opts?: Opts<ImportExpression> | null): node is ImportExpression;
-declare function isMetaProperty(node: Node$1 | null | undefined, opts?: Opts<MetaProperty> | null): node is MetaProperty;
-declare function isClassMethod(node: Node$1 | null | undefined, opts?: Opts<ClassMethod> | null): node is ClassMethod;
-declare function isObjectPattern(node: Node$1 | null | undefined, opts?: Opts<ObjectPattern> | null): node is ObjectPattern;
-declare function isSpreadElement(node: Node$1 | null | undefined, opts?: Opts<SpreadElement> | null): node is SpreadElement;
-declare function isSuper(node: Node$1 | null | undefined, opts?: Opts<Super> | null): node is Super;
-declare function isTaggedTemplateExpression(node: Node$1 | null | undefined, opts?: Opts<TaggedTemplateExpression> | null): node is TaggedTemplateExpression;
-declare function isTemplateElement(node: Node$1 | null | undefined, opts?: Opts<TemplateElement> | null): node is TemplateElement;
-declare function isTemplateLiteral(node: Node$1 | null | undefined, opts?: Opts<TemplateLiteral> | null): node is TemplateLiteral;
-declare function isYieldExpression(node: Node$1 | null | undefined, opts?: Opts<YieldExpression> | null): node is YieldExpression;
-declare function isAwaitExpression(node: Node$1 | null | undefined, opts?: Opts<AwaitExpression> | null): node is AwaitExpression;
-declare function isImport(node: Node$1 | null | undefined, opts?: Opts<Import> | null): node is Import;
-declare function isBigIntLiteral(node: Node$1 | null | undefined, opts?: Opts<BigIntLiteral> | null): node is BigIntLiteral;
-declare function isExportNamespaceSpecifier(node: Node$1 | null | undefined, opts?: Opts<ExportNamespaceSpecifier> | null): node is ExportNamespaceSpecifier;
-declare function isOptionalMemberExpression(node: Node$1 | null | undefined, opts?: Opts<OptionalMemberExpression> | null): node is OptionalMemberExpression;
-declare function isOptionalCallExpression(node: Node$1 | null | undefined, opts?: Opts<OptionalCallExpression> | null): node is OptionalCallExpression;
-declare function isClassProperty(node: Node$1 | null | undefined, opts?: Opts<ClassProperty> | null): node is ClassProperty;
-declare function isClassAccessorProperty(node: Node$1 | null | undefined, opts?: Opts<ClassAccessorProperty> | null): node is ClassAccessorProperty;
-declare function isClassPrivateProperty(node: Node$1 | null | undefined, opts?: Opts<ClassPrivateProperty> | null): node is ClassPrivateProperty;
-declare function isClassPrivateMethod(node: Node$1 | null | undefined, opts?: Opts<ClassPrivateMethod> | null): node is ClassPrivateMethod;
-declare function isPrivateName(node: Node$1 | null | undefined, opts?: Opts<PrivateName> | null): node is PrivateName;
-declare function isStaticBlock(node: Node$1 | null | undefined, opts?: Opts<StaticBlock> | null): node is StaticBlock;
-declare function isImportAttribute(node: Node$1 | null | undefined, opts?: Opts<ImportAttribute> | null): node is ImportAttribute;
-declare function isAnyTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<AnyTypeAnnotation> | null): node is AnyTypeAnnotation;
-declare function isArrayTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<ArrayTypeAnnotation> | null): node is ArrayTypeAnnotation;
-declare function isBooleanTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<BooleanTypeAnnotation> | null): node is BooleanTypeAnnotation;
-declare function isBooleanLiteralTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<BooleanLiteralTypeAnnotation> | null): node is BooleanLiteralTypeAnnotation;
-declare function isNullLiteralTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<NullLiteralTypeAnnotation> | null): node is NullLiteralTypeAnnotation;
-declare function isClassImplements(node: Node$1 | null | undefined, opts?: Opts<ClassImplements> | null): node is ClassImplements;
-declare function isDeclareClass(node: Node$1 | null | undefined, opts?: Opts<DeclareClass> | null): node is DeclareClass;
-declare function isDeclareFunction(node: Node$1 | null | undefined, opts?: Opts<DeclareFunction> | null): node is DeclareFunction;
-declare function isDeclareInterface(node: Node$1 | null | undefined, opts?: Opts<DeclareInterface> | null): node is DeclareInterface;
-declare function isDeclareModule(node: Node$1 | null | undefined, opts?: Opts<DeclareModule> | null): node is DeclareModule;
-declare function isDeclareModuleExports(node: Node$1 | null | undefined, opts?: Opts<DeclareModuleExports> | null): node is DeclareModuleExports;
-declare function isDeclareTypeAlias(node: Node$1 | null | undefined, opts?: Opts<DeclareTypeAlias> | null): node is DeclareTypeAlias;
-declare function isDeclareOpaqueType(node: Node$1 | null | undefined, opts?: Opts<DeclareOpaqueType> | null): node is DeclareOpaqueType;
-declare function isDeclareVariable(node: Node$1 | null | undefined, opts?: Opts<DeclareVariable> | null): node is DeclareVariable;
-declare function isDeclareExportDeclaration(node: Node$1 | null | undefined, opts?: Opts<DeclareExportDeclaration> | null): node is DeclareExportDeclaration;
-declare function isDeclareExportAllDeclaration(node: Node$1 | null | undefined, opts?: Opts<DeclareExportAllDeclaration> | null): node is DeclareExportAllDeclaration;
-declare function isDeclaredPredicate(node: Node$1 | null | undefined, opts?: Opts<DeclaredPredicate> | null): node is DeclaredPredicate;
-declare function isExistsTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<ExistsTypeAnnotation> | null): node is ExistsTypeAnnotation;
-declare function isFunctionTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<FunctionTypeAnnotation> | null): node is FunctionTypeAnnotation;
-declare function isFunctionTypeParam(node: Node$1 | null | undefined, opts?: Opts<FunctionTypeParam> | null): node is FunctionTypeParam;
-declare function isGenericTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<GenericTypeAnnotation> | null): node is GenericTypeAnnotation;
-declare function isInferredPredicate(node: Node$1 | null | undefined, opts?: Opts<InferredPredicate> | null): node is InferredPredicate;
-declare function isInterfaceExtends(node: Node$1 | null | undefined, opts?: Opts<InterfaceExtends> | null): node is InterfaceExtends;
-declare function isInterfaceDeclaration(node: Node$1 | null | undefined, opts?: Opts<InterfaceDeclaration> | null): node is InterfaceDeclaration;
-declare function isInterfaceTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<InterfaceTypeAnnotation> | null): node is InterfaceTypeAnnotation;
-declare function isIntersectionTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<IntersectionTypeAnnotation> | null): node is IntersectionTypeAnnotation;
-declare function isMixedTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<MixedTypeAnnotation> | null): node is MixedTypeAnnotation;
-declare function isEmptyTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<EmptyTypeAnnotation> | null): node is EmptyTypeAnnotation;
-declare function isNullableTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<NullableTypeAnnotation> | null): node is NullableTypeAnnotation;
-declare function isNumberLiteralTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<NumberLiteralTypeAnnotation> | null): node is NumberLiteralTypeAnnotation;
-declare function isNumberTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<NumberTypeAnnotation> | null): node is NumberTypeAnnotation;
-declare function isObjectTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeAnnotation> | null): node is ObjectTypeAnnotation;
-declare function isObjectTypeInternalSlot(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeInternalSlot> | null): node is ObjectTypeInternalSlot;
-declare function isObjectTypeCallProperty(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeCallProperty> | null): node is ObjectTypeCallProperty;
-declare function isObjectTypeIndexer(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeIndexer> | null): node is ObjectTypeIndexer;
-declare function isObjectTypeProperty(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeProperty> | null): node is ObjectTypeProperty;
-declare function isObjectTypeSpreadProperty(node: Node$1 | null | undefined, opts?: Opts<ObjectTypeSpreadProperty> | null): node is ObjectTypeSpreadProperty;
-declare function isOpaqueType(node: Node$1 | null | undefined, opts?: Opts<OpaqueType> | null): node is OpaqueType;
-declare function isQualifiedTypeIdentifier(node: Node$1 | null | undefined, opts?: Opts<QualifiedTypeIdentifier> | null): node is QualifiedTypeIdentifier;
-declare function isStringLiteralTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<StringLiteralTypeAnnotation> | null): node is StringLiteralTypeAnnotation;
-declare function isStringTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<StringTypeAnnotation> | null): node is StringTypeAnnotation;
-declare function isSymbolTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<SymbolTypeAnnotation> | null): node is SymbolTypeAnnotation;
-declare function isThisTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<ThisTypeAnnotation> | null): node is ThisTypeAnnotation;
-declare function isTupleTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<TupleTypeAnnotation> | null): node is TupleTypeAnnotation;
-declare function isTypeofTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<TypeofTypeAnnotation> | null): node is TypeofTypeAnnotation;
-declare function isTypeAlias(node: Node$1 | null | undefined, opts?: Opts<TypeAlias> | null): node is TypeAlias;
-declare function isTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<TypeAnnotation> | null): node is TypeAnnotation;
-declare function isTypeCastExpression(node: Node$1 | null | undefined, opts?: Opts<TypeCastExpression> | null): node is TypeCastExpression;
-declare function isTypeParameter(node: Node$1 | null | undefined, opts?: Opts<TypeParameter> | null): node is TypeParameter;
-declare function isTypeParameterDeclaration(node: Node$1 | null | undefined, opts?: Opts<TypeParameterDeclaration> | null): node is TypeParameterDeclaration;
-declare function isTypeParameterInstantiation(node: Node$1 | null | undefined, opts?: Opts<TypeParameterInstantiation> | null): node is TypeParameterInstantiation;
-declare function isUnionTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<UnionTypeAnnotation> | null): node is UnionTypeAnnotation;
-declare function isVariance(node: Node$1 | null | undefined, opts?: Opts<Variance> | null): node is Variance;
-declare function isVoidTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<VoidTypeAnnotation> | null): node is VoidTypeAnnotation;
-declare function isEnumDeclaration(node: Node$1 | null | undefined, opts?: Opts<EnumDeclaration> | null): node is EnumDeclaration;
-declare function isEnumBooleanBody(node: Node$1 | null | undefined, opts?: Opts<EnumBooleanBody> | null): node is EnumBooleanBody;
-declare function isEnumNumberBody(node: Node$1 | null | undefined, opts?: Opts<EnumNumberBody> | null): node is EnumNumberBody;
-declare function isEnumStringBody(node: Node$1 | null | undefined, opts?: Opts<EnumStringBody> | null): node is EnumStringBody;
-declare function isEnumSymbolBody(node: Node$1 | null | undefined, opts?: Opts<EnumSymbolBody> | null): node is EnumSymbolBody;
-declare function isEnumBooleanMember(node: Node$1 | null | undefined, opts?: Opts<EnumBooleanMember> | null): node is EnumBooleanMember;
-declare function isEnumNumberMember(node: Node$1 | null | undefined, opts?: Opts<EnumNumberMember> | null): node is EnumNumberMember;
-declare function isEnumStringMember(node: Node$1 | null | undefined, opts?: Opts<EnumStringMember> | null): node is EnumStringMember;
-declare function isEnumDefaultedMember(node: Node$1 | null | undefined, opts?: Opts<EnumDefaultedMember> | null): node is EnumDefaultedMember;
-declare function isIndexedAccessType(node: Node$1 | null | undefined, opts?: Opts<IndexedAccessType> | null): node is IndexedAccessType;
-declare function isOptionalIndexedAccessType(node: Node$1 | null | undefined, opts?: Opts<OptionalIndexedAccessType> | null): node is OptionalIndexedAccessType;
-declare function isJSXAttribute(node: Node$1 | null | undefined, opts?: Opts<JSXAttribute> | null): node is JSXAttribute;
-declare function isJSXClosingElement(node: Node$1 | null | undefined, opts?: Opts<JSXClosingElement> | null): node is JSXClosingElement;
-declare function isJSXElement(node: Node$1 | null | undefined, opts?: Opts<JSXElement> | null): node is JSXElement;
-declare function isJSXEmptyExpression(node: Node$1 | null | undefined, opts?: Opts<JSXEmptyExpression> | null): node is JSXEmptyExpression;
-declare function isJSXExpressionContainer(node: Node$1 | null | undefined, opts?: Opts<JSXExpressionContainer> | null): node is JSXExpressionContainer;
-declare function isJSXSpreadChild(node: Node$1 | null | undefined, opts?: Opts<JSXSpreadChild> | null): node is JSXSpreadChild;
-declare function isJSXIdentifier(node: Node$1 | null | undefined, opts?: Opts<JSXIdentifier> | null): node is JSXIdentifier;
-declare function isJSXMemberExpression(node: Node$1 | null | undefined, opts?: Opts<JSXMemberExpression> | null): node is JSXMemberExpression;
-declare function isJSXNamespacedName(node: Node$1 | null | undefined, opts?: Opts<JSXNamespacedName> | null): node is JSXNamespacedName;
-declare function isJSXOpeningElement(node: Node$1 | null | undefined, opts?: Opts<JSXOpeningElement> | null): node is JSXOpeningElement;
-declare function isJSXSpreadAttribute(node: Node$1 | null | undefined, opts?: Opts<JSXSpreadAttribute> | null): node is JSXSpreadAttribute;
-declare function isJSXText(node: Node$1 | null | undefined, opts?: Opts<JSXText> | null): node is JSXText;
-declare function isJSXFragment(node: Node$1 | null | undefined, opts?: Opts<JSXFragment> | null): node is JSXFragment;
-declare function isJSXOpeningFragment(node: Node$1 | null | undefined, opts?: Opts<JSXOpeningFragment> | null): node is JSXOpeningFragment;
-declare function isJSXClosingFragment(node: Node$1 | null | undefined, opts?: Opts<JSXClosingFragment> | null): node is JSXClosingFragment;
-declare function isNoop(node: Node$1 | null | undefined, opts?: Opts<Noop> | null): node is Noop;
-declare function isPlaceholder(node: Node$1 | null | undefined, opts?: Opts<Placeholder> | null): node is Placeholder;
-declare function isV8IntrinsicIdentifier(node: Node$1 | null | undefined, opts?: Opts<V8IntrinsicIdentifier> | null): node is V8IntrinsicIdentifier;
-declare function isArgumentPlaceholder(node: Node$1 | null | undefined, opts?: Opts<ArgumentPlaceholder> | null): node is ArgumentPlaceholder;
-declare function isBindExpression(node: Node$1 | null | undefined, opts?: Opts<BindExpression> | null): node is BindExpression;
-declare function isDecorator(node: Node$1 | null | undefined, opts?: Opts<Decorator> | null): node is Decorator;
-declare function isDoExpression(node: Node$1 | null | undefined, opts?: Opts<DoExpression> | null): node is DoExpression;
-declare function isExportDefaultSpecifier(node: Node$1 | null | undefined, opts?: Opts<ExportDefaultSpecifier> | null): node is ExportDefaultSpecifier;
-declare function isRecordExpression(node: Node$1 | null | undefined, opts?: Opts<RecordExpression> | null): node is RecordExpression;
-declare function isTupleExpression(node: Node$1 | null | undefined, opts?: Opts<TupleExpression> | null): node is TupleExpression;
-declare function isDecimalLiteral(node: Node$1 | null | undefined, opts?: Opts<DecimalLiteral> | null): node is DecimalLiteral;
-declare function isModuleExpression(node: Node$1 | null | undefined, opts?: Opts<ModuleExpression> | null): node is ModuleExpression;
-declare function isTopicReference(node: Node$1 | null | undefined, opts?: Opts<TopicReference> | null): node is TopicReference;
-declare function isPipelineTopicExpression(node: Node$1 | null | undefined, opts?: Opts<PipelineTopicExpression> | null): node is PipelineTopicExpression;
-declare function isPipelineBareFunction(node: Node$1 | null | undefined, opts?: Opts<PipelineBareFunction> | null): node is PipelineBareFunction;
-declare function isPipelinePrimaryTopicReference(node: Node$1 | null | undefined, opts?: Opts<PipelinePrimaryTopicReference> | null): node is PipelinePrimaryTopicReference;
-declare function isVoidPattern(node: Node$1 | null | undefined, opts?: Opts<VoidPattern> | null): node is VoidPattern;
-declare function isTSParameterProperty(node: Node$1 | null | undefined, opts?: Opts<TSParameterProperty> | null): node is TSParameterProperty;
-declare function isTSDeclareFunction(node: Node$1 | null | undefined, opts?: Opts<TSDeclareFunction> | null): node is TSDeclareFunction;
-declare function isTSDeclareMethod(node: Node$1 | null | undefined, opts?: Opts<TSDeclareMethod> | null): node is TSDeclareMethod;
-declare function isTSQualifiedName(node: Node$1 | null | undefined, opts?: Opts<TSQualifiedName> | null): node is TSQualifiedName;
-declare function isTSCallSignatureDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSCallSignatureDeclaration> | null): node is TSCallSignatureDeclaration;
-declare function isTSConstructSignatureDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSConstructSignatureDeclaration> | null): node is TSConstructSignatureDeclaration;
-declare function isTSPropertySignature(node: Node$1 | null | undefined, opts?: Opts<TSPropertySignature> | null): node is TSPropertySignature;
-declare function isTSMethodSignature(node: Node$1 | null | undefined, opts?: Opts<TSMethodSignature> | null): node is TSMethodSignature;
-declare function isTSIndexSignature(node: Node$1 | null | undefined, opts?: Opts<TSIndexSignature> | null): node is TSIndexSignature;
-declare function isTSAnyKeyword(node: Node$1 | null | undefined, opts?: Opts<TSAnyKeyword> | null): node is TSAnyKeyword;
-declare function isTSBooleanKeyword(node: Node$1 | null | undefined, opts?: Opts<TSBooleanKeyword> | null): node is TSBooleanKeyword;
-declare function isTSBigIntKeyword(node: Node$1 | null | undefined, opts?: Opts<TSBigIntKeyword> | null): node is TSBigIntKeyword;
-declare function isTSIntrinsicKeyword(node: Node$1 | null | undefined, opts?: Opts<TSIntrinsicKeyword> | null): node is TSIntrinsicKeyword;
-declare function isTSNeverKeyword(node: Node$1 | null | undefined, opts?: Opts<TSNeverKeyword> | null): node is TSNeverKeyword;
-declare function isTSNullKeyword(node: Node$1 | null | undefined, opts?: Opts<TSNullKeyword> | null): node is TSNullKeyword;
-declare function isTSNumberKeyword(node: Node$1 | null | undefined, opts?: Opts<TSNumberKeyword> | null): node is TSNumberKeyword;
-declare function isTSObjectKeyword(node: Node$1 | null | undefined, opts?: Opts<TSObjectKeyword> | null): node is TSObjectKeyword;
-declare function isTSStringKeyword(node: Node$1 | null | undefined, opts?: Opts<TSStringKeyword> | null): node is TSStringKeyword;
-declare function isTSSymbolKeyword(node: Node$1 | null | undefined, opts?: Opts<TSSymbolKeyword> | null): node is TSSymbolKeyword;
-declare function isTSUndefinedKeyword(node: Node$1 | null | undefined, opts?: Opts<TSUndefinedKeyword> | null): node is TSUndefinedKeyword;
-declare function isTSUnknownKeyword(node: Node$1 | null | undefined, opts?: Opts<TSUnknownKeyword> | null): node is TSUnknownKeyword;
-declare function isTSVoidKeyword(node: Node$1 | null | undefined, opts?: Opts<TSVoidKeyword> | null): node is TSVoidKeyword;
-declare function isTSThisType(node: Node$1 | null | undefined, opts?: Opts<TSThisType> | null): node is TSThisType;
-declare function isTSFunctionType(node: Node$1 | null | undefined, opts?: Opts<TSFunctionType> | null): node is TSFunctionType;
-declare function isTSConstructorType(node: Node$1 | null | undefined, opts?: Opts<TSConstructorType> | null): node is TSConstructorType;
-declare function isTSTypeReference(node: Node$1 | null | undefined, opts?: Opts<TSTypeReference> | null): node is TSTypeReference;
-declare function isTSTypePredicate(node: Node$1 | null | undefined, opts?: Opts<TSTypePredicate> | null): node is TSTypePredicate;
-declare function isTSTypeQuery(node: Node$1 | null | undefined, opts?: Opts<TSTypeQuery> | null): node is TSTypeQuery;
-declare function isTSTypeLiteral(node: Node$1 | null | undefined, opts?: Opts<TSTypeLiteral> | null): node is TSTypeLiteral;
-declare function isTSArrayType(node: Node$1 | null | undefined, opts?: Opts<TSArrayType> | null): node is TSArrayType;
-declare function isTSTupleType(node: Node$1 | null | undefined, opts?: Opts<TSTupleType> | null): node is TSTupleType;
-declare function isTSOptionalType(node: Node$1 | null | undefined, opts?: Opts<TSOptionalType> | null): node is TSOptionalType;
-declare function isTSRestType(node: Node$1 | null | undefined, opts?: Opts<TSRestType> | null): node is TSRestType;
-declare function isTSNamedTupleMember(node: Node$1 | null | undefined, opts?: Opts<TSNamedTupleMember> | null): node is TSNamedTupleMember;
-declare function isTSUnionType(node: Node$1 | null | undefined, opts?: Opts<TSUnionType> | null): node is TSUnionType;
-declare function isTSIntersectionType(node: Node$1 | null | undefined, opts?: Opts<TSIntersectionType> | null): node is TSIntersectionType;
-declare function isTSConditionalType(node: Node$1 | null | undefined, opts?: Opts<TSConditionalType> | null): node is TSConditionalType;
-declare function isTSInferType(node: Node$1 | null | undefined, opts?: Opts<TSInferType> | null): node is TSInferType;
-declare function isTSParenthesizedType(node: Node$1 | null | undefined, opts?: Opts<TSParenthesizedType> | null): node is TSParenthesizedType;
-declare function isTSTypeOperator(node: Node$1 | null | undefined, opts?: Opts<TSTypeOperator> | null): node is TSTypeOperator;
-declare function isTSIndexedAccessType(node: Node$1 | null | undefined, opts?: Opts<TSIndexedAccessType> | null): node is TSIndexedAccessType;
-declare function isTSMappedType(node: Node$1 | null | undefined, opts?: Opts<TSMappedType> | null): node is TSMappedType;
-declare function isTSTemplateLiteralType(node: Node$1 | null | undefined, opts?: Opts<TSTemplateLiteralType> | null): node is TSTemplateLiteralType;
-declare function isTSLiteralType(node: Node$1 | null | undefined, opts?: Opts<TSLiteralType> | null): node is TSLiteralType;
-declare function isTSExpressionWithTypeArguments(node: Node$1 | null | undefined, opts?: Opts<TSExpressionWithTypeArguments> | null): node is TSExpressionWithTypeArguments;
-declare function isTSInterfaceDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSInterfaceDeclaration> | null): node is TSInterfaceDeclaration;
-declare function isTSInterfaceBody(node: Node$1 | null | undefined, opts?: Opts<TSInterfaceBody> | null): node is TSInterfaceBody;
-declare function isTSTypeAliasDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSTypeAliasDeclaration> | null): node is TSTypeAliasDeclaration;
-declare function isTSInstantiationExpression(node: Node$1 | null | undefined, opts?: Opts<TSInstantiationExpression> | null): node is TSInstantiationExpression;
-declare function isTSAsExpression(node: Node$1 | null | undefined, opts?: Opts<TSAsExpression> | null): node is TSAsExpression;
-declare function isTSSatisfiesExpression(node: Node$1 | null | undefined, opts?: Opts<TSSatisfiesExpression> | null): node is TSSatisfiesExpression;
-declare function isTSTypeAssertion(node: Node$1 | null | undefined, opts?: Opts<TSTypeAssertion> | null): node is TSTypeAssertion;
-declare function isTSEnumBody(node: Node$1 | null | undefined, opts?: Opts<TSEnumBody> | null): node is TSEnumBody;
-declare function isTSEnumDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSEnumDeclaration> | null): node is TSEnumDeclaration;
-declare function isTSEnumMember(node: Node$1 | null | undefined, opts?: Opts<TSEnumMember> | null): node is TSEnumMember;
-declare function isTSModuleDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSModuleDeclaration> | null): node is TSModuleDeclaration;
-declare function isTSModuleBlock(node: Node$1 | null | undefined, opts?: Opts<TSModuleBlock> | null): node is TSModuleBlock;
-declare function isTSImportType(node: Node$1 | null | undefined, opts?: Opts<TSImportType> | null): node is TSImportType;
-declare function isTSImportEqualsDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSImportEqualsDeclaration> | null): node is TSImportEqualsDeclaration;
-declare function isTSExternalModuleReference(node: Node$1 | null | undefined, opts?: Opts<TSExternalModuleReference> | null): node is TSExternalModuleReference;
-declare function isTSNonNullExpression(node: Node$1 | null | undefined, opts?: Opts<TSNonNullExpression> | null): node is TSNonNullExpression;
-declare function isTSExportAssignment(node: Node$1 | null | undefined, opts?: Opts<TSExportAssignment> | null): node is TSExportAssignment;
-declare function isTSNamespaceExportDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSNamespaceExportDeclaration> | null): node is TSNamespaceExportDeclaration;
-declare function isTSTypeAnnotation(node: Node$1 | null | undefined, opts?: Opts<TSTypeAnnotation> | null): node is TSTypeAnnotation;
-declare function isTSTypeParameterInstantiation(node: Node$1 | null | undefined, opts?: Opts<TSTypeParameterInstantiation> | null): node is TSTypeParameterInstantiation;
-declare function isTSTypeParameterDeclaration(node: Node$1 | null | undefined, opts?: Opts<TSTypeParameterDeclaration> | null): node is TSTypeParameterDeclaration;
-declare function isTSTypeParameter(node: Node$1 | null | undefined, opts?: Opts<TSTypeParameter> | null): node is TSTypeParameter;
-declare function isStandardized(node: Node$1 | null | undefined, opts?: Opts<Standardized> | null): node is Standardized;
-declare function isExpression(node: Node$1 | null | undefined, opts?: Opts<Expression> | null): node is Expression;
-declare function isBinary(node: Node$1 | null | undefined, opts?: Opts<Binary> | null): node is Binary;
-declare function isScopable(node: Node$1 | null | undefined, opts?: Opts<Scopable> | null): node is Scopable;
-declare function isBlockParent(node: Node$1 | null | undefined, opts?: Opts<BlockParent> | null): node is BlockParent;
-declare function isBlock(node: Node$1 | null | undefined, opts?: Opts<Block> | null): node is Block;
-declare function isStatement(node: Node$1 | null | undefined, opts?: Opts<Statement> | null): node is Statement;
-declare function isTerminatorless(node: Node$1 | null | undefined, opts?: Opts<Terminatorless> | null): node is Terminatorless;
-declare function isCompletionStatement(node: Node$1 | null | undefined, opts?: Opts<CompletionStatement> | null): node is CompletionStatement;
-declare function isConditional(node: Node$1 | null | undefined, opts?: Opts<Conditional> | null): node is Conditional;
-declare function isLoop(node: Node$1 | null | undefined, opts?: Opts<Loop> | null): node is Loop;
-declare function isWhile(node: Node$1 | null | undefined, opts?: Opts<While> | null): node is While;
-declare function isExpressionWrapper(node: Node$1 | null | undefined, opts?: Opts<ExpressionWrapper> | null): node is ExpressionWrapper;
-declare function isFor(node: Node$1 | null | undefined, opts?: Opts<For> | null): node is For;
-declare function isForXStatement(node: Node$1 | null | undefined, opts?: Opts<ForXStatement> | null): node is ForXStatement;
-declare function isFunction(node: Node$1 | null | undefined, opts?: Opts<Function> | null): node is Function;
-declare function isFunctionParent(node: Node$1 | null | undefined, opts?: Opts<FunctionParent> | null): node is FunctionParent;
-declare function isPureish(node: Node$1 | null | undefined, opts?: Opts<Pureish> | null): node is Pureish;
-declare function isDeclaration(node: Node$1 | null | undefined, opts?: Opts<Declaration> | null): node is Declaration;
-declare function isFunctionParameter(node: Node$1 | null | undefined, opts?: Opts<FunctionParameter> | null): node is FunctionParameter;
-declare function isPatternLike(node: Node$1 | null | undefined, opts?: Opts<PatternLike> | null): node is PatternLike;
-declare function isLVal(node: Node$1 | null | undefined, opts?: Opts<LVal> | null): node is LVal;
-declare function isTSEntityName(node: Node$1 | null | undefined, opts?: Opts<TSEntityName> | null): node is TSEntityName;
-declare function isLiteral(node: Node$1 | null | undefined, opts?: Opts<Literal> | null): node is Literal;
-declare function isUserWhitespacable(node: Node$1 | null | undefined, opts?: Opts<UserWhitespacable> | null): node is UserWhitespacable;
-declare function isMethod(node: Node$1 | null | undefined, opts?: Opts<Method> | null): node is Method;
-declare function isObjectMember(node: Node$1 | null | undefined, opts?: Opts<ObjectMember> | null): node is ObjectMember;
-declare function isProperty(node: Node$1 | null | undefined, opts?: Opts<Property> | null): node is Property;
-declare function isUnaryLike(node: Node$1 | null | undefined, opts?: Opts<UnaryLike> | null): node is UnaryLike;
-declare function isPattern(node: Node$1 | null | undefined, opts?: Opts<Pattern> | null): node is Pattern;
-declare function isClass(node: Node$1 | null | undefined, opts?: Opts<Class> | null): node is Class;
-declare function isImportOrExportDeclaration(node: Node$1 | null | undefined, opts?: Opts<ImportOrExportDeclaration> | null): node is ImportOrExportDeclaration;
-declare function isExportDeclaration(node: Node$1 | null | undefined, opts?: Opts<ExportDeclaration> | null): node is ExportDeclaration;
-declare function isModuleSpecifier(node: Node$1 | null | undefined, opts?: Opts<ModuleSpecifier> | null): node is ModuleSpecifier;
-declare function isAccessor(node: Node$1 | null | undefined, opts?: Opts<Accessor> | null): node is Accessor;
-declare function isPrivate(node: Node$1 | null | undefined, opts?: Opts<Private> | null): node is Private;
-declare function isFlow(node: Node$1 | null | undefined, opts?: Opts<Flow> | null): node is Flow;
-declare function isFlowType(node: Node$1 | null | undefined, opts?: Opts<FlowType> | null): node is FlowType;
-declare function isFlowBaseAnnotation(node: Node$1 | null | undefined, opts?: Opts<FlowBaseAnnotation> | null): node is FlowBaseAnnotation;
-declare function isFlowDeclaration(node: Node$1 | null | undefined, opts?: Opts<FlowDeclaration> | null): node is FlowDeclaration;
-declare function isFlowPredicate(node: Node$1 | null | undefined, opts?: Opts<FlowPredicate> | null): node is FlowPredicate;
-declare function isEnumBody(node: Node$1 | null | undefined, opts?: Opts<EnumBody> | null): node is EnumBody;
-declare function isEnumMember(node: Node$1 | null | undefined, opts?: Opts<EnumMember> | null): node is EnumMember;
-declare function isJSX(node: Node$1 | null | undefined, opts?: Opts<JSX> | null): node is JSX;
-declare function isMiscellaneous(node: Node$1 | null | undefined, opts?: Opts<Miscellaneous> | null): node is Miscellaneous;
-declare function isTypeScript(node: Node$1 | null | undefined, opts?: Opts<TypeScript> | null): node is TypeScript;
-declare function isTSTypeElement(node: Node$1 | null | undefined, opts?: Opts<TSTypeElement> | null): node is TSTypeElement;
-declare function isTSType(node: Node$1 | null | undefined, opts?: Opts<TSType> | null): node is TSType;
-declare function isTSBaseType(node: Node$1 | null | undefined, opts?: Opts<TSBaseType> | null): node is TSBaseType;
+declare function isArrayExpression(node: Node$1 | null | undefined): node is ArrayExpression;
+declare function isArrayExpression<Opts extends Options$2<ArrayExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ArrayExpression & Opts;
+declare function isAssignmentExpression(node: Node$1 | null | undefined): node is AssignmentExpression;
+declare function isAssignmentExpression<Opts extends Options$2<AssignmentExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is AssignmentExpression & Opts;
+declare function isBinaryExpression(node: Node$1 | null | undefined): node is BinaryExpression;
+declare function isBinaryExpression<Opts extends Options$2<BinaryExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BinaryExpression & Opts;
+declare function isInterpreterDirective(node: Node$1 | null | undefined): node is InterpreterDirective;
+declare function isInterpreterDirective<Opts extends Options$2<InterpreterDirective>>(node: Node$1 | null | undefined, opts?: Opts | null): node is InterpreterDirective & Opts;
+declare function isDirective(node: Node$1 | null | undefined): node is Directive;
+declare function isDirective<Opts extends Options$2<Directive>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Directive & Opts;
+declare function isDirectiveLiteral(node: Node$1 | null | undefined): node is DirectiveLiteral;
+declare function isDirectiveLiteral<Opts extends Options$2<DirectiveLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DirectiveLiteral & Opts;
+declare function isBlockStatement(node: Node$1 | null | undefined): node is BlockStatement;
+declare function isBlockStatement<Opts extends Options$2<BlockStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BlockStatement & Opts;
+declare function isBreakStatement(node: Node$1 | null | undefined): node is BreakStatement;
+declare function isBreakStatement<Opts extends Options$2<BreakStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BreakStatement & Opts;
+declare function isCallExpression(node: Node$1 | null | undefined): node is CallExpression;
+declare function isCallExpression<Opts extends Options$2<CallExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is CallExpression & Opts;
+declare function isCatchClause(node: Node$1 | null | undefined): node is CatchClause;
+declare function isCatchClause<Opts extends Options$2<CatchClause>>(node: Node$1 | null | undefined, opts?: Opts | null): node is CatchClause & Opts;
+declare function isConditionalExpression(node: Node$1 | null | undefined): node is ConditionalExpression;
+declare function isConditionalExpression<Opts extends Options$2<ConditionalExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ConditionalExpression & Opts;
+declare function isContinueStatement(node: Node$1 | null | undefined): node is ContinueStatement;
+declare function isContinueStatement<Opts extends Options$2<ContinueStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ContinueStatement & Opts;
+declare function isDebuggerStatement(node: Node$1 | null | undefined): node is DebuggerStatement;
+declare function isDebuggerStatement<Opts extends Options$2<DebuggerStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DebuggerStatement & Opts;
+declare function isDoWhileStatement(node: Node$1 | null | undefined): node is DoWhileStatement;
+declare function isDoWhileStatement<Opts extends Options$2<DoWhileStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DoWhileStatement & Opts;
+declare function isEmptyStatement(node: Node$1 | null | undefined): node is EmptyStatement;
+declare function isEmptyStatement<Opts extends Options$2<EmptyStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EmptyStatement & Opts;
+declare function isExpressionStatement(node: Node$1 | null | undefined): node is ExpressionStatement;
+declare function isExpressionStatement<Opts extends Options$2<ExpressionStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExpressionStatement & Opts;
+declare function isFile(node: Node$1 | null | undefined): node is File;
+declare function isFile<Opts extends Options$2<File>>(node: Node$1 | null | undefined, opts?: Opts | null): node is File & Opts;
+declare function isForInStatement(node: Node$1 | null | undefined): node is ForInStatement;
+declare function isForInStatement<Opts extends Options$2<ForInStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ForInStatement & Opts;
+declare function isForStatement(node: Node$1 | null | undefined): node is ForStatement;
+declare function isForStatement<Opts extends Options$2<ForStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ForStatement & Opts;
+declare function isFunctionDeclaration(node: Node$1 | null | undefined): node is FunctionDeclaration;
+declare function isFunctionDeclaration<Opts extends Options$2<FunctionDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionDeclaration & Opts;
+declare function isFunctionExpression(node: Node$1 | null | undefined): node is FunctionExpression;
+declare function isFunctionExpression<Opts extends Options$2<FunctionExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionExpression & Opts;
+declare function isIdentifier(node: Node$1 | null | undefined): node is Identifier;
+declare function isIdentifier<Opts extends Options$2<Identifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Identifier & Opts;
+declare function isIfStatement(node: Node$1 | null | undefined): node is IfStatement;
+declare function isIfStatement<Opts extends Options$2<IfStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is IfStatement & Opts;
+declare function isLabeledStatement(node: Node$1 | null | undefined): node is LabeledStatement;
+declare function isLabeledStatement<Opts extends Options$2<LabeledStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is LabeledStatement & Opts;
+declare function isStringLiteral(node: Node$1 | null | undefined): node is StringLiteral;
+declare function isStringLiteral<Opts extends Options$2<StringLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is StringLiteral & Opts;
+declare function isNumericLiteral(node: Node$1 | null | undefined): node is NumericLiteral;
+declare function isNumericLiteral<Opts extends Options$2<NumericLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NumericLiteral & Opts;
+declare function isNullLiteral(node: Node$1 | null | undefined): node is NullLiteral;
+declare function isNullLiteral<Opts extends Options$2<NullLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NullLiteral & Opts;
+declare function isBooleanLiteral(node: Node$1 | null | undefined): node is BooleanLiteral;
+declare function isBooleanLiteral<Opts extends Options$2<BooleanLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BooleanLiteral & Opts;
+declare function isRegExpLiteral(node: Node$1 | null | undefined): node is RegExpLiteral;
+declare function isRegExpLiteral<Opts extends Options$2<RegExpLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is RegExpLiteral & Opts;
+declare function isLogicalExpression(node: Node$1 | null | undefined): node is LogicalExpression;
+declare function isLogicalExpression<Opts extends Options$2<LogicalExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is LogicalExpression & Opts;
+declare function isMemberExpression(node: Node$1 | null | undefined): node is MemberExpression;
+declare function isMemberExpression<Opts extends Options$2<MemberExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is MemberExpression & Opts;
+declare function isNewExpression(node: Node$1 | null | undefined): node is NewExpression;
+declare function isNewExpression<Opts extends Options$2<NewExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NewExpression & Opts;
+declare function isProgram(node: Node$1 | null | undefined): node is Program;
+declare function isProgram<Opts extends Options$2<Program>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Program & Opts;
+declare function isObjectExpression(node: Node$1 | null | undefined): node is ObjectExpression;
+declare function isObjectExpression<Opts extends Options$2<ObjectExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectExpression & Opts;
+declare function isObjectMethod(node: Node$1 | null | undefined): node is ObjectMethod;
+declare function isObjectMethod<Opts extends Options$2<ObjectMethod>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectMethod & Opts;
+declare function isObjectProperty(node: Node$1 | null | undefined): node is ObjectProperty;
+declare function isObjectProperty<Opts extends Options$2<ObjectProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectProperty & Opts;
+declare function isRestElement(node: Node$1 | null | undefined): node is RestElement;
+declare function isRestElement<Opts extends Options$2<RestElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is RestElement & Opts;
+declare function isReturnStatement(node: Node$1 | null | undefined): node is ReturnStatement;
+declare function isReturnStatement<Opts extends Options$2<ReturnStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ReturnStatement & Opts;
+declare function isSequenceExpression(node: Node$1 | null | undefined): node is SequenceExpression;
+declare function isSequenceExpression<Opts extends Options$2<SequenceExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is SequenceExpression & Opts;
+declare function isParenthesizedExpression(node: Node$1 | null | undefined): node is ParenthesizedExpression;
+declare function isParenthesizedExpression<Opts extends Options$2<ParenthesizedExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ParenthesizedExpression & Opts;
+declare function isSwitchCase(node: Node$1 | null | undefined): node is SwitchCase;
+declare function isSwitchCase<Opts extends Options$2<SwitchCase>>(node: Node$1 | null | undefined, opts?: Opts | null): node is SwitchCase & Opts;
+declare function isSwitchStatement(node: Node$1 | null | undefined): node is SwitchStatement;
+declare function isSwitchStatement<Opts extends Options$2<SwitchStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is SwitchStatement & Opts;
+declare function isThisExpression(node: Node$1 | null | undefined): node is ThisExpression;
+declare function isThisExpression<Opts extends Options$2<ThisExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ThisExpression & Opts;
+declare function isThrowStatement(node: Node$1 | null | undefined): node is ThrowStatement;
+declare function isThrowStatement<Opts extends Options$2<ThrowStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ThrowStatement & Opts;
+declare function isTryStatement(node: Node$1 | null | undefined): node is TryStatement;
+declare function isTryStatement<Opts extends Options$2<TryStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TryStatement & Opts;
+declare function isUnaryExpression(node: Node$1 | null | undefined): node is UnaryExpression;
+declare function isUnaryExpression<Opts extends Options$2<UnaryExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is UnaryExpression & Opts;
+declare function isUpdateExpression(node: Node$1 | null | undefined): node is UpdateExpression;
+declare function isUpdateExpression<Opts extends Options$2<UpdateExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is UpdateExpression & Opts;
+declare function isVariableDeclaration(node: Node$1 | null | undefined): node is VariableDeclaration;
+declare function isVariableDeclaration<Opts extends Options$2<VariableDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is VariableDeclaration & Opts;
+declare function isVariableDeclarator(node: Node$1 | null | undefined): node is VariableDeclarator;
+declare function isVariableDeclarator<Opts extends Options$2<VariableDeclarator>>(node: Node$1 | null | undefined, opts?: Opts | null): node is VariableDeclarator & Opts;
+declare function isWhileStatement(node: Node$1 | null | undefined): node is WhileStatement;
+declare function isWhileStatement<Opts extends Options$2<WhileStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is WhileStatement & Opts;
+declare function isWithStatement(node: Node$1 | null | undefined): node is WithStatement;
+declare function isWithStatement<Opts extends Options$2<WithStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is WithStatement & Opts;
+declare function isAssignmentPattern(node: Node$1 | null | undefined): node is AssignmentPattern;
+declare function isAssignmentPattern<Opts extends Options$2<AssignmentPattern>>(node: Node$1 | null | undefined, opts?: Opts | null): node is AssignmentPattern & Opts;
+declare function isArrayPattern(node: Node$1 | null | undefined): node is ArrayPattern;
+declare function isArrayPattern<Opts extends Options$2<ArrayPattern>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ArrayPattern & Opts;
+declare function isArrowFunctionExpression(node: Node$1 | null | undefined): node is ArrowFunctionExpression;
+declare function isArrowFunctionExpression<Opts extends Options$2<ArrowFunctionExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ArrowFunctionExpression & Opts;
+declare function isClassBody(node: Node$1 | null | undefined): node is ClassBody;
+declare function isClassBody<Opts extends Options$2<ClassBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassBody & Opts;
+declare function isClassExpression(node: Node$1 | null | undefined): node is ClassExpression;
+declare function isClassExpression<Opts extends Options$2<ClassExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassExpression & Opts;
+declare function isClassDeclaration(node: Node$1 | null | undefined): node is ClassDeclaration;
+declare function isClassDeclaration<Opts extends Options$2<ClassDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassDeclaration & Opts;
+declare function isExportAllDeclaration(node: Node$1 | null | undefined): node is ExportAllDeclaration;
+declare function isExportAllDeclaration<Opts extends Options$2<ExportAllDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportAllDeclaration & Opts;
+declare function isExportDefaultDeclaration(node: Node$1 | null | undefined): node is ExportDefaultDeclaration;
+declare function isExportDefaultDeclaration<Opts extends Options$2<ExportDefaultDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportDefaultDeclaration & Opts;
+declare function isExportNamedDeclaration(node: Node$1 | null | undefined): node is ExportNamedDeclaration;
+declare function isExportNamedDeclaration<Opts extends Options$2<ExportNamedDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportNamedDeclaration & Opts;
+declare function isExportSpecifier(node: Node$1 | null | undefined): node is ExportSpecifier;
+declare function isExportSpecifier<Opts extends Options$2<ExportSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportSpecifier & Opts;
+declare function isForOfStatement(node: Node$1 | null | undefined): node is ForOfStatement;
+declare function isForOfStatement<Opts extends Options$2<ForOfStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ForOfStatement & Opts;
+declare function isImportDeclaration(node: Node$1 | null | undefined): node is ImportDeclaration;
+declare function isImportDeclaration<Opts extends Options$2<ImportDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportDeclaration & Opts;
+declare function isImportDefaultSpecifier(node: Node$1 | null | undefined): node is ImportDefaultSpecifier;
+declare function isImportDefaultSpecifier<Opts extends Options$2<ImportDefaultSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportDefaultSpecifier & Opts;
+declare function isImportNamespaceSpecifier(node: Node$1 | null | undefined): node is ImportNamespaceSpecifier;
+declare function isImportNamespaceSpecifier<Opts extends Options$2<ImportNamespaceSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportNamespaceSpecifier & Opts;
+declare function isImportSpecifier(node: Node$1 | null | undefined): node is ImportSpecifier;
+declare function isImportSpecifier<Opts extends Options$2<ImportSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportSpecifier & Opts;
+declare function isImportExpression(node: Node$1 | null | undefined): node is ImportExpression;
+declare function isImportExpression<Opts extends Options$2<ImportExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportExpression & Opts;
+declare function isMetaProperty(node: Node$1 | null | undefined): node is MetaProperty;
+declare function isMetaProperty<Opts extends Options$2<MetaProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is MetaProperty & Opts;
+declare function isClassMethod(node: Node$1 | null | undefined): node is ClassMethod;
+declare function isClassMethod<Opts extends Options$2<ClassMethod>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassMethod & Opts;
+declare function isObjectPattern(node: Node$1 | null | undefined): node is ObjectPattern;
+declare function isObjectPattern<Opts extends Options$2<ObjectPattern>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectPattern & Opts;
+declare function isSpreadElement(node: Node$1 | null | undefined): node is SpreadElement;
+declare function isSpreadElement<Opts extends Options$2<SpreadElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is SpreadElement & Opts;
+declare function isSuper(node: Node$1 | null | undefined): node is Super;
+declare function isSuper<Opts extends Options$2<Super>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Super & Opts;
+declare function isTaggedTemplateExpression(node: Node$1 | null | undefined): node is TaggedTemplateExpression;
+declare function isTaggedTemplateExpression<Opts extends Options$2<TaggedTemplateExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TaggedTemplateExpression & Opts;
+declare function isTemplateElement(node: Node$1 | null | undefined): node is TemplateElement;
+declare function isTemplateElement<Opts extends Options$2<TemplateElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TemplateElement & Opts;
+declare function isTemplateLiteral(node: Node$1 | null | undefined): node is TemplateLiteral;
+declare function isTemplateLiteral<Opts extends Options$2<TemplateLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TemplateLiteral & Opts;
+declare function isYieldExpression(node: Node$1 | null | undefined): node is YieldExpression;
+declare function isYieldExpression<Opts extends Options$2<YieldExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is YieldExpression & Opts;
+declare function isAwaitExpression(node: Node$1 | null | undefined): node is AwaitExpression;
+declare function isAwaitExpression<Opts extends Options$2<AwaitExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is AwaitExpression & Opts;
+declare function isImport(node: Node$1 | null | undefined): node is Import;
+declare function isImport<Opts extends Options$2<Import>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Import & Opts;
+declare function isBigIntLiteral(node: Node$1 | null | undefined): node is BigIntLiteral;
+declare function isBigIntLiteral<Opts extends Options$2<BigIntLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BigIntLiteral & Opts;
+declare function isExportNamespaceSpecifier(node: Node$1 | null | undefined): node is ExportNamespaceSpecifier;
+declare function isExportNamespaceSpecifier<Opts extends Options$2<ExportNamespaceSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportNamespaceSpecifier & Opts;
+declare function isOptionalMemberExpression(node: Node$1 | null | undefined): node is OptionalMemberExpression;
+declare function isOptionalMemberExpression<Opts extends Options$2<OptionalMemberExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is OptionalMemberExpression & Opts;
+declare function isOptionalCallExpression(node: Node$1 | null | undefined): node is OptionalCallExpression;
+declare function isOptionalCallExpression<Opts extends Options$2<OptionalCallExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is OptionalCallExpression & Opts;
+declare function isClassProperty(node: Node$1 | null | undefined): node is ClassProperty;
+declare function isClassProperty<Opts extends Options$2<ClassProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassProperty & Opts;
+declare function isClassAccessorProperty(node: Node$1 | null | undefined): node is ClassAccessorProperty;
+declare function isClassAccessorProperty<Opts extends Options$2<ClassAccessorProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassAccessorProperty & Opts;
+declare function isClassPrivateProperty(node: Node$1 | null | undefined): node is ClassPrivateProperty;
+declare function isClassPrivateProperty<Opts extends Options$2<ClassPrivateProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassPrivateProperty & Opts;
+declare function isClassPrivateMethod(node: Node$1 | null | undefined): node is ClassPrivateMethod;
+declare function isClassPrivateMethod<Opts extends Options$2<ClassPrivateMethod>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassPrivateMethod & Opts;
+declare function isPrivateName(node: Node$1 | null | undefined): node is PrivateName;
+declare function isPrivateName<Opts extends Options$2<PrivateName>>(node: Node$1 | null | undefined, opts?: Opts | null): node is PrivateName & Opts;
+declare function isStaticBlock(node: Node$1 | null | undefined): node is StaticBlock;
+declare function isStaticBlock<Opts extends Options$2<StaticBlock>>(node: Node$1 | null | undefined, opts?: Opts | null): node is StaticBlock & Opts;
+declare function isImportAttribute(node: Node$1 | null | undefined): node is ImportAttribute;
+declare function isImportAttribute<Opts extends Options$2<ImportAttribute>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportAttribute & Opts;
+declare function isAnyTypeAnnotation(node: Node$1 | null | undefined): node is AnyTypeAnnotation;
+declare function isAnyTypeAnnotation<Opts extends Options$2<AnyTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is AnyTypeAnnotation & Opts;
+declare function isArrayTypeAnnotation(node: Node$1 | null | undefined): node is ArrayTypeAnnotation;
+declare function isArrayTypeAnnotation<Opts extends Options$2<ArrayTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ArrayTypeAnnotation & Opts;
+declare function isBooleanTypeAnnotation(node: Node$1 | null | undefined): node is BooleanTypeAnnotation;
+declare function isBooleanTypeAnnotation<Opts extends Options$2<BooleanTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BooleanTypeAnnotation & Opts;
+declare function isBooleanLiteralTypeAnnotation(node: Node$1 | null | undefined): node is BooleanLiteralTypeAnnotation;
+declare function isBooleanLiteralTypeAnnotation<Opts extends Options$2<BooleanLiteralTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BooleanLiteralTypeAnnotation & Opts;
+declare function isNullLiteralTypeAnnotation(node: Node$1 | null | undefined): node is NullLiteralTypeAnnotation;
+declare function isNullLiteralTypeAnnotation<Opts extends Options$2<NullLiteralTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NullLiteralTypeAnnotation & Opts;
+declare function isClassImplements(node: Node$1 | null | undefined): node is ClassImplements;
+declare function isClassImplements<Opts extends Options$2<ClassImplements>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ClassImplements & Opts;
+declare function isDeclareClass(node: Node$1 | null | undefined): node is DeclareClass;
+declare function isDeclareClass<Opts extends Options$2<DeclareClass>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareClass & Opts;
+declare function isDeclareFunction(node: Node$1 | null | undefined): node is DeclareFunction;
+declare function isDeclareFunction<Opts extends Options$2<DeclareFunction>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareFunction & Opts;
+declare function isDeclareInterface(node: Node$1 | null | undefined): node is DeclareInterface;
+declare function isDeclareInterface<Opts extends Options$2<DeclareInterface>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareInterface & Opts;
+declare function isDeclareModule(node: Node$1 | null | undefined): node is DeclareModule;
+declare function isDeclareModule<Opts extends Options$2<DeclareModule>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareModule & Opts;
+declare function isDeclareModuleExports(node: Node$1 | null | undefined): node is DeclareModuleExports;
+declare function isDeclareModuleExports<Opts extends Options$2<DeclareModuleExports>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareModuleExports & Opts;
+declare function isDeclareTypeAlias(node: Node$1 | null | undefined): node is DeclareTypeAlias;
+declare function isDeclareTypeAlias<Opts extends Options$2<DeclareTypeAlias>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareTypeAlias & Opts;
+declare function isDeclareOpaqueType(node: Node$1 | null | undefined): node is DeclareOpaqueType;
+declare function isDeclareOpaqueType<Opts extends Options$2<DeclareOpaqueType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareOpaqueType & Opts;
+declare function isDeclareVariable(node: Node$1 | null | undefined): node is DeclareVariable;
+declare function isDeclareVariable<Opts extends Options$2<DeclareVariable>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareVariable & Opts;
+declare function isDeclareExportDeclaration(node: Node$1 | null | undefined): node is DeclareExportDeclaration;
+declare function isDeclareExportDeclaration<Opts extends Options$2<DeclareExportDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareExportDeclaration & Opts;
+declare function isDeclareExportAllDeclaration(node: Node$1 | null | undefined): node is DeclareExportAllDeclaration;
+declare function isDeclareExportAllDeclaration<Opts extends Options$2<DeclareExportAllDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclareExportAllDeclaration & Opts;
+declare function isDeclaredPredicate(node: Node$1 | null | undefined): node is DeclaredPredicate;
+declare function isDeclaredPredicate<Opts extends Options$2<DeclaredPredicate>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DeclaredPredicate & Opts;
+declare function isExistsTypeAnnotation(node: Node$1 | null | undefined): node is ExistsTypeAnnotation;
+declare function isExistsTypeAnnotation<Opts extends Options$2<ExistsTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExistsTypeAnnotation & Opts;
+declare function isFunctionTypeAnnotation(node: Node$1 | null | undefined): node is FunctionTypeAnnotation;
+declare function isFunctionTypeAnnotation<Opts extends Options$2<FunctionTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionTypeAnnotation & Opts;
+declare function isFunctionTypeParam(node: Node$1 | null | undefined): node is FunctionTypeParam;
+declare function isFunctionTypeParam<Opts extends Options$2<FunctionTypeParam>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionTypeParam & Opts;
+declare function isGenericTypeAnnotation(node: Node$1 | null | undefined): node is GenericTypeAnnotation;
+declare function isGenericTypeAnnotation<Opts extends Options$2<GenericTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is GenericTypeAnnotation & Opts;
+declare function isInferredPredicate(node: Node$1 | null | undefined): node is InferredPredicate;
+declare function isInferredPredicate<Opts extends Options$2<InferredPredicate>>(node: Node$1 | null | undefined, opts?: Opts | null): node is InferredPredicate & Opts;
+declare function isInterfaceExtends(node: Node$1 | null | undefined): node is InterfaceExtends;
+declare function isInterfaceExtends<Opts extends Options$2<InterfaceExtends>>(node: Node$1 | null | undefined, opts?: Opts | null): node is InterfaceExtends & Opts;
+declare function isInterfaceDeclaration(node: Node$1 | null | undefined): node is InterfaceDeclaration;
+declare function isInterfaceDeclaration<Opts extends Options$2<InterfaceDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is InterfaceDeclaration & Opts;
+declare function isInterfaceTypeAnnotation(node: Node$1 | null | undefined): node is InterfaceTypeAnnotation;
+declare function isInterfaceTypeAnnotation<Opts extends Options$2<InterfaceTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is InterfaceTypeAnnotation & Opts;
+declare function isIntersectionTypeAnnotation(node: Node$1 | null | undefined): node is IntersectionTypeAnnotation;
+declare function isIntersectionTypeAnnotation<Opts extends Options$2<IntersectionTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is IntersectionTypeAnnotation & Opts;
+declare function isMixedTypeAnnotation(node: Node$1 | null | undefined): node is MixedTypeAnnotation;
+declare function isMixedTypeAnnotation<Opts extends Options$2<MixedTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is MixedTypeAnnotation & Opts;
+declare function isEmptyTypeAnnotation(node: Node$1 | null | undefined): node is EmptyTypeAnnotation;
+declare function isEmptyTypeAnnotation<Opts extends Options$2<EmptyTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EmptyTypeAnnotation & Opts;
+declare function isNullableTypeAnnotation(node: Node$1 | null | undefined): node is NullableTypeAnnotation;
+declare function isNullableTypeAnnotation<Opts extends Options$2<NullableTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NullableTypeAnnotation & Opts;
+declare function isNumberLiteralTypeAnnotation(node: Node$1 | null | undefined): node is NumberLiteralTypeAnnotation;
+declare function isNumberLiteralTypeAnnotation<Opts extends Options$2<NumberLiteralTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NumberLiteralTypeAnnotation & Opts;
+declare function isNumberTypeAnnotation(node: Node$1 | null | undefined): node is NumberTypeAnnotation;
+declare function isNumberTypeAnnotation<Opts extends Options$2<NumberTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is NumberTypeAnnotation & Opts;
+declare function isObjectTypeAnnotation(node: Node$1 | null | undefined): node is ObjectTypeAnnotation;
+declare function isObjectTypeAnnotation<Opts extends Options$2<ObjectTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeAnnotation & Opts;
+declare function isObjectTypeInternalSlot(node: Node$1 | null | undefined): node is ObjectTypeInternalSlot;
+declare function isObjectTypeInternalSlot<Opts extends Options$2<ObjectTypeInternalSlot>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeInternalSlot & Opts;
+declare function isObjectTypeCallProperty(node: Node$1 | null | undefined): node is ObjectTypeCallProperty;
+declare function isObjectTypeCallProperty<Opts extends Options$2<ObjectTypeCallProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeCallProperty & Opts;
+declare function isObjectTypeIndexer(node: Node$1 | null | undefined): node is ObjectTypeIndexer;
+declare function isObjectTypeIndexer<Opts extends Options$2<ObjectTypeIndexer>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeIndexer & Opts;
+declare function isObjectTypeProperty(node: Node$1 | null | undefined): node is ObjectTypeProperty;
+declare function isObjectTypeProperty<Opts extends Options$2<ObjectTypeProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeProperty & Opts;
+declare function isObjectTypeSpreadProperty(node: Node$1 | null | undefined): node is ObjectTypeSpreadProperty;
+declare function isObjectTypeSpreadProperty<Opts extends Options$2<ObjectTypeSpreadProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectTypeSpreadProperty & Opts;
+declare function isOpaqueType(node: Node$1 | null | undefined): node is OpaqueType;
+declare function isOpaqueType<Opts extends Options$2<OpaqueType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is OpaqueType & Opts;
+declare function isQualifiedTypeIdentifier(node: Node$1 | null | undefined): node is QualifiedTypeIdentifier;
+declare function isQualifiedTypeIdentifier<Opts extends Options$2<QualifiedTypeIdentifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is QualifiedTypeIdentifier & Opts;
+declare function isStringLiteralTypeAnnotation(node: Node$1 | null | undefined): node is StringLiteralTypeAnnotation;
+declare function isStringLiteralTypeAnnotation<Opts extends Options$2<StringLiteralTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is StringLiteralTypeAnnotation & Opts;
+declare function isStringTypeAnnotation(node: Node$1 | null | undefined): node is StringTypeAnnotation;
+declare function isStringTypeAnnotation<Opts extends Options$2<StringTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is StringTypeAnnotation & Opts;
+declare function isSymbolTypeAnnotation(node: Node$1 | null | undefined): node is SymbolTypeAnnotation;
+declare function isSymbolTypeAnnotation<Opts extends Options$2<SymbolTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is SymbolTypeAnnotation & Opts;
+declare function isThisTypeAnnotation(node: Node$1 | null | undefined): node is ThisTypeAnnotation;
+declare function isThisTypeAnnotation<Opts extends Options$2<ThisTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ThisTypeAnnotation & Opts;
+declare function isTupleTypeAnnotation(node: Node$1 | null | undefined): node is TupleTypeAnnotation;
+declare function isTupleTypeAnnotation<Opts extends Options$2<TupleTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TupleTypeAnnotation & Opts;
+declare function isTypeofTypeAnnotation(node: Node$1 | null | undefined): node is TypeofTypeAnnotation;
+declare function isTypeofTypeAnnotation<Opts extends Options$2<TypeofTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeofTypeAnnotation & Opts;
+declare function isTypeAlias(node: Node$1 | null | undefined): node is TypeAlias;
+declare function isTypeAlias<Opts extends Options$2<TypeAlias>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeAlias & Opts;
+declare function isTypeAnnotation(node: Node$1 | null | undefined): node is TypeAnnotation;
+declare function isTypeAnnotation<Opts extends Options$2<TypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeAnnotation & Opts;
+declare function isTypeCastExpression(node: Node$1 | null | undefined): node is TypeCastExpression;
+declare function isTypeCastExpression<Opts extends Options$2<TypeCastExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeCastExpression & Opts;
+declare function isTypeParameter(node: Node$1 | null | undefined): node is TypeParameter;
+declare function isTypeParameter<Opts extends Options$2<TypeParameter>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeParameter & Opts;
+declare function isTypeParameterDeclaration(node: Node$1 | null | undefined): node is TypeParameterDeclaration;
+declare function isTypeParameterDeclaration<Opts extends Options$2<TypeParameterDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeParameterDeclaration & Opts;
+declare function isTypeParameterInstantiation(node: Node$1 | null | undefined): node is TypeParameterInstantiation;
+declare function isTypeParameterInstantiation<Opts extends Options$2<TypeParameterInstantiation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeParameterInstantiation & Opts;
+declare function isUnionTypeAnnotation(node: Node$1 | null | undefined): node is UnionTypeAnnotation;
+declare function isUnionTypeAnnotation<Opts extends Options$2<UnionTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is UnionTypeAnnotation & Opts;
+declare function isVariance(node: Node$1 | null | undefined): node is Variance;
+declare function isVariance<Opts extends Options$2<Variance>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Variance & Opts;
+declare function isVoidTypeAnnotation(node: Node$1 | null | undefined): node is VoidTypeAnnotation;
+declare function isVoidTypeAnnotation<Opts extends Options$2<VoidTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is VoidTypeAnnotation & Opts;
+declare function isEnumDeclaration(node: Node$1 | null | undefined): node is EnumDeclaration;
+declare function isEnumDeclaration<Opts extends Options$2<EnumDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumDeclaration & Opts;
+declare function isEnumBooleanBody(node: Node$1 | null | undefined): node is EnumBooleanBody;
+declare function isEnumBooleanBody<Opts extends Options$2<EnumBooleanBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumBooleanBody & Opts;
+declare function isEnumNumberBody(node: Node$1 | null | undefined): node is EnumNumberBody;
+declare function isEnumNumberBody<Opts extends Options$2<EnumNumberBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumNumberBody & Opts;
+declare function isEnumStringBody(node: Node$1 | null | undefined): node is EnumStringBody;
+declare function isEnumStringBody<Opts extends Options$2<EnumStringBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumStringBody & Opts;
+declare function isEnumSymbolBody(node: Node$1 | null | undefined): node is EnumSymbolBody;
+declare function isEnumSymbolBody<Opts extends Options$2<EnumSymbolBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumSymbolBody & Opts;
+declare function isEnumBooleanMember(node: Node$1 | null | undefined): node is EnumBooleanMember;
+declare function isEnumBooleanMember<Opts extends Options$2<EnumBooleanMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumBooleanMember & Opts;
+declare function isEnumNumberMember(node: Node$1 | null | undefined): node is EnumNumberMember;
+declare function isEnumNumberMember<Opts extends Options$2<EnumNumberMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumNumberMember & Opts;
+declare function isEnumStringMember(node: Node$1 | null | undefined): node is EnumStringMember;
+declare function isEnumStringMember<Opts extends Options$2<EnumStringMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumStringMember & Opts;
+declare function isEnumDefaultedMember(node: Node$1 | null | undefined): node is EnumDefaultedMember;
+declare function isEnumDefaultedMember<Opts extends Options$2<EnumDefaultedMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumDefaultedMember & Opts;
+declare function isIndexedAccessType(node: Node$1 | null | undefined): node is IndexedAccessType;
+declare function isIndexedAccessType<Opts extends Options$2<IndexedAccessType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is IndexedAccessType & Opts;
+declare function isOptionalIndexedAccessType(node: Node$1 | null | undefined): node is OptionalIndexedAccessType;
+declare function isOptionalIndexedAccessType<Opts extends Options$2<OptionalIndexedAccessType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is OptionalIndexedAccessType & Opts;
+declare function isJSXAttribute(node: Node$1 | null | undefined): node is JSXAttribute;
+declare function isJSXAttribute<Opts extends Options$2<JSXAttribute>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXAttribute & Opts;
+declare function isJSXClosingElement(node: Node$1 | null | undefined): node is JSXClosingElement;
+declare function isJSXClosingElement<Opts extends Options$2<JSXClosingElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXClosingElement & Opts;
+declare function isJSXElement(node: Node$1 | null | undefined): node is JSXElement;
+declare function isJSXElement<Opts extends Options$2<JSXElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXElement & Opts;
+declare function isJSXEmptyExpression(node: Node$1 | null | undefined): node is JSXEmptyExpression;
+declare function isJSXEmptyExpression<Opts extends Options$2<JSXEmptyExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXEmptyExpression & Opts;
+declare function isJSXExpressionContainer(node: Node$1 | null | undefined): node is JSXExpressionContainer;
+declare function isJSXExpressionContainer<Opts extends Options$2<JSXExpressionContainer>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXExpressionContainer & Opts;
+declare function isJSXSpreadChild(node: Node$1 | null | undefined): node is JSXSpreadChild;
+declare function isJSXSpreadChild<Opts extends Options$2<JSXSpreadChild>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXSpreadChild & Opts;
+declare function isJSXIdentifier(node: Node$1 | null | undefined): node is JSXIdentifier;
+declare function isJSXIdentifier<Opts extends Options$2<JSXIdentifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXIdentifier & Opts;
+declare function isJSXMemberExpression(node: Node$1 | null | undefined): node is JSXMemberExpression;
+declare function isJSXMemberExpression<Opts extends Options$2<JSXMemberExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXMemberExpression & Opts;
+declare function isJSXNamespacedName(node: Node$1 | null | undefined): node is JSXNamespacedName;
+declare function isJSXNamespacedName<Opts extends Options$2<JSXNamespacedName>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXNamespacedName & Opts;
+declare function isJSXOpeningElement(node: Node$1 | null | undefined): node is JSXOpeningElement;
+declare function isJSXOpeningElement<Opts extends Options$2<JSXOpeningElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXOpeningElement & Opts;
+declare function isJSXSpreadAttribute(node: Node$1 | null | undefined): node is JSXSpreadAttribute;
+declare function isJSXSpreadAttribute<Opts extends Options$2<JSXSpreadAttribute>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXSpreadAttribute & Opts;
+declare function isJSXText(node: Node$1 | null | undefined): node is JSXText;
+declare function isJSXText<Opts extends Options$2<JSXText>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXText & Opts;
+declare function isJSXFragment(node: Node$1 | null | undefined): node is JSXFragment;
+declare function isJSXFragment<Opts extends Options$2<JSXFragment>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXFragment & Opts;
+declare function isJSXOpeningFragment(node: Node$1 | null | undefined): node is JSXOpeningFragment;
+declare function isJSXOpeningFragment<Opts extends Options$2<JSXOpeningFragment>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXOpeningFragment & Opts;
+declare function isJSXClosingFragment(node: Node$1 | null | undefined): node is JSXClosingFragment;
+declare function isJSXClosingFragment<Opts extends Options$2<JSXClosingFragment>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSXClosingFragment & Opts;
+declare function isNoop(node: Node$1 | null | undefined): node is Noop;
+declare function isNoop<Opts extends Options$2<Noop>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Noop & Opts;
+declare function isPlaceholder(node: Node$1 | null | undefined): node is Placeholder;
+declare function isPlaceholder<Opts extends Options$2<Placeholder>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Placeholder & Opts;
+declare function isV8IntrinsicIdentifier(node: Node$1 | null | undefined): node is V8IntrinsicIdentifier;
+declare function isV8IntrinsicIdentifier<Opts extends Options$2<V8IntrinsicIdentifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is V8IntrinsicIdentifier & Opts;
+declare function isArgumentPlaceholder(node: Node$1 | null | undefined): node is ArgumentPlaceholder;
+declare function isArgumentPlaceholder<Opts extends Options$2<ArgumentPlaceholder>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ArgumentPlaceholder & Opts;
+declare function isBindExpression(node: Node$1 | null | undefined): node is BindExpression;
+declare function isBindExpression<Opts extends Options$2<BindExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BindExpression & Opts;
+declare function isDecorator(node: Node$1 | null | undefined): node is Decorator;
+declare function isDecorator<Opts extends Options$2<Decorator>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Decorator & Opts;
+declare function isDoExpression(node: Node$1 | null | undefined): node is DoExpression;
+declare function isDoExpression<Opts extends Options$2<DoExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DoExpression & Opts;
+declare function isExportDefaultSpecifier(node: Node$1 | null | undefined): node is ExportDefaultSpecifier;
+declare function isExportDefaultSpecifier<Opts extends Options$2<ExportDefaultSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportDefaultSpecifier & Opts;
+declare function isRecordExpression(node: Node$1 | null | undefined): node is RecordExpression;
+declare function isRecordExpression<Opts extends Options$2<RecordExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is RecordExpression & Opts;
+declare function isTupleExpression(node: Node$1 | null | undefined): node is TupleExpression;
+declare function isTupleExpression<Opts extends Options$2<TupleExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TupleExpression & Opts;
+declare function isDecimalLiteral(node: Node$1 | null | undefined): node is DecimalLiteral;
+declare function isDecimalLiteral<Opts extends Options$2<DecimalLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is DecimalLiteral & Opts;
+declare function isModuleExpression(node: Node$1 | null | undefined): node is ModuleExpression;
+declare function isModuleExpression<Opts extends Options$2<ModuleExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ModuleExpression & Opts;
+declare function isTopicReference(node: Node$1 | null | undefined): node is TopicReference;
+declare function isTopicReference<Opts extends Options$2<TopicReference>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TopicReference & Opts;
+declare function isPipelineTopicExpression(node: Node$1 | null | undefined): node is PipelineTopicExpression;
+declare function isPipelineTopicExpression<Opts extends Options$2<PipelineTopicExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is PipelineTopicExpression & Opts;
+declare function isPipelineBareFunction(node: Node$1 | null | undefined): node is PipelineBareFunction;
+declare function isPipelineBareFunction<Opts extends Options$2<PipelineBareFunction>>(node: Node$1 | null | undefined, opts?: Opts | null): node is PipelineBareFunction & Opts;
+declare function isPipelinePrimaryTopicReference(node: Node$1 | null | undefined): node is PipelinePrimaryTopicReference;
+declare function isPipelinePrimaryTopicReference<Opts extends Options$2<PipelinePrimaryTopicReference>>(node: Node$1 | null | undefined, opts?: Opts | null): node is PipelinePrimaryTopicReference & Opts;
+declare function isVoidPattern(node: Node$1 | null | undefined): node is VoidPattern;
+declare function isVoidPattern<Opts extends Options$2<VoidPattern>>(node: Node$1 | null | undefined, opts?: Opts | null): node is VoidPattern & Opts;
+declare function isTSParameterProperty(node: Node$1 | null | undefined): node is TSParameterProperty;
+declare function isTSParameterProperty<Opts extends Options$2<TSParameterProperty>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSParameterProperty & Opts;
+declare function isTSDeclareFunction(node: Node$1 | null | undefined): node is TSDeclareFunction;
+declare function isTSDeclareFunction<Opts extends Options$2<TSDeclareFunction>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSDeclareFunction & Opts;
+declare function isTSDeclareMethod(node: Node$1 | null | undefined): node is TSDeclareMethod;
+declare function isTSDeclareMethod<Opts extends Options$2<TSDeclareMethod>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSDeclareMethod & Opts;
+declare function isTSQualifiedName(node: Node$1 | null | undefined): node is TSQualifiedName;
+declare function isTSQualifiedName<Opts extends Options$2<TSQualifiedName>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSQualifiedName & Opts;
+declare function isTSCallSignatureDeclaration(node: Node$1 | null | undefined): node is TSCallSignatureDeclaration;
+declare function isTSCallSignatureDeclaration<Opts extends Options$2<TSCallSignatureDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSCallSignatureDeclaration & Opts;
+declare function isTSConstructSignatureDeclaration(node: Node$1 | null | undefined): node is TSConstructSignatureDeclaration;
+declare function isTSConstructSignatureDeclaration<Opts extends Options$2<TSConstructSignatureDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSConstructSignatureDeclaration & Opts;
+declare function isTSPropertySignature(node: Node$1 | null | undefined): node is TSPropertySignature;
+declare function isTSPropertySignature<Opts extends Options$2<TSPropertySignature>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSPropertySignature & Opts;
+declare function isTSMethodSignature(node: Node$1 | null | undefined): node is TSMethodSignature;
+declare function isTSMethodSignature<Opts extends Options$2<TSMethodSignature>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSMethodSignature & Opts;
+declare function isTSIndexSignature(node: Node$1 | null | undefined): node is TSIndexSignature;
+declare function isTSIndexSignature<Opts extends Options$2<TSIndexSignature>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSIndexSignature & Opts;
+declare function isTSAnyKeyword(node: Node$1 | null | undefined): node is TSAnyKeyword;
+declare function isTSAnyKeyword<Opts extends Options$2<TSAnyKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSAnyKeyword & Opts;
+declare function isTSBooleanKeyword(node: Node$1 | null | undefined): node is TSBooleanKeyword;
+declare function isTSBooleanKeyword<Opts extends Options$2<TSBooleanKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSBooleanKeyword & Opts;
+declare function isTSBigIntKeyword(node: Node$1 | null | undefined): node is TSBigIntKeyword;
+declare function isTSBigIntKeyword<Opts extends Options$2<TSBigIntKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSBigIntKeyword & Opts;
+declare function isTSIntrinsicKeyword(node: Node$1 | null | undefined): node is TSIntrinsicKeyword;
+declare function isTSIntrinsicKeyword<Opts extends Options$2<TSIntrinsicKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSIntrinsicKeyword & Opts;
+declare function isTSNeverKeyword(node: Node$1 | null | undefined): node is TSNeverKeyword;
+declare function isTSNeverKeyword<Opts extends Options$2<TSNeverKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNeverKeyword & Opts;
+declare function isTSNullKeyword(node: Node$1 | null | undefined): node is TSNullKeyword;
+declare function isTSNullKeyword<Opts extends Options$2<TSNullKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNullKeyword & Opts;
+declare function isTSNumberKeyword(node: Node$1 | null | undefined): node is TSNumberKeyword;
+declare function isTSNumberKeyword<Opts extends Options$2<TSNumberKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNumberKeyword & Opts;
+declare function isTSObjectKeyword(node: Node$1 | null | undefined): node is TSObjectKeyword;
+declare function isTSObjectKeyword<Opts extends Options$2<TSObjectKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSObjectKeyword & Opts;
+declare function isTSStringKeyword(node: Node$1 | null | undefined): node is TSStringKeyword;
+declare function isTSStringKeyword<Opts extends Options$2<TSStringKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSStringKeyword & Opts;
+declare function isTSSymbolKeyword(node: Node$1 | null | undefined): node is TSSymbolKeyword;
+declare function isTSSymbolKeyword<Opts extends Options$2<TSSymbolKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSSymbolKeyword & Opts;
+declare function isTSUndefinedKeyword(node: Node$1 | null | undefined): node is TSUndefinedKeyword;
+declare function isTSUndefinedKeyword<Opts extends Options$2<TSUndefinedKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSUndefinedKeyword & Opts;
+declare function isTSUnknownKeyword(node: Node$1 | null | undefined): node is TSUnknownKeyword;
+declare function isTSUnknownKeyword<Opts extends Options$2<TSUnknownKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSUnknownKeyword & Opts;
+declare function isTSVoidKeyword(node: Node$1 | null | undefined): node is TSVoidKeyword;
+declare function isTSVoidKeyword<Opts extends Options$2<TSVoidKeyword>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSVoidKeyword & Opts;
+declare function isTSThisType(node: Node$1 | null | undefined): node is TSThisType;
+declare function isTSThisType<Opts extends Options$2<TSThisType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSThisType & Opts;
+declare function isTSFunctionType(node: Node$1 | null | undefined): node is TSFunctionType;
+declare function isTSFunctionType<Opts extends Options$2<TSFunctionType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSFunctionType & Opts;
+declare function isTSConstructorType(node: Node$1 | null | undefined): node is TSConstructorType;
+declare function isTSConstructorType<Opts extends Options$2<TSConstructorType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSConstructorType & Opts;
+declare function isTSTypeReference(node: Node$1 | null | undefined): node is TSTypeReference;
+declare function isTSTypeReference<Opts extends Options$2<TSTypeReference>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeReference & Opts;
+declare function isTSTypePredicate(node: Node$1 | null | undefined): node is TSTypePredicate;
+declare function isTSTypePredicate<Opts extends Options$2<TSTypePredicate>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypePredicate & Opts;
+declare function isTSTypeQuery(node: Node$1 | null | undefined): node is TSTypeQuery;
+declare function isTSTypeQuery<Opts extends Options$2<TSTypeQuery>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeQuery & Opts;
+declare function isTSTypeLiteral(node: Node$1 | null | undefined): node is TSTypeLiteral;
+declare function isTSTypeLiteral<Opts extends Options$2<TSTypeLiteral>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeLiteral & Opts;
+declare function isTSArrayType(node: Node$1 | null | undefined): node is TSArrayType;
+declare function isTSArrayType<Opts extends Options$2<TSArrayType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSArrayType & Opts;
+declare function isTSTupleType(node: Node$1 | null | undefined): node is TSTupleType;
+declare function isTSTupleType<Opts extends Options$2<TSTupleType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTupleType & Opts;
+declare function isTSOptionalType(node: Node$1 | null | undefined): node is TSOptionalType;
+declare function isTSOptionalType<Opts extends Options$2<TSOptionalType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSOptionalType & Opts;
+declare function isTSRestType(node: Node$1 | null | undefined): node is TSRestType;
+declare function isTSRestType<Opts extends Options$2<TSRestType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSRestType & Opts;
+declare function isTSNamedTupleMember(node: Node$1 | null | undefined): node is TSNamedTupleMember;
+declare function isTSNamedTupleMember<Opts extends Options$2<TSNamedTupleMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNamedTupleMember & Opts;
+declare function isTSUnionType(node: Node$1 | null | undefined): node is TSUnionType;
+declare function isTSUnionType<Opts extends Options$2<TSUnionType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSUnionType & Opts;
+declare function isTSIntersectionType(node: Node$1 | null | undefined): node is TSIntersectionType;
+declare function isTSIntersectionType<Opts extends Options$2<TSIntersectionType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSIntersectionType & Opts;
+declare function isTSConditionalType(node: Node$1 | null | undefined): node is TSConditionalType;
+declare function isTSConditionalType<Opts extends Options$2<TSConditionalType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSConditionalType & Opts;
+declare function isTSInferType(node: Node$1 | null | undefined): node is TSInferType;
+declare function isTSInferType<Opts extends Options$2<TSInferType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSInferType & Opts;
+declare function isTSParenthesizedType(node: Node$1 | null | undefined): node is TSParenthesizedType;
+declare function isTSParenthesizedType<Opts extends Options$2<TSParenthesizedType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSParenthesizedType & Opts;
+declare function isTSTypeOperator(node: Node$1 | null | undefined): node is TSTypeOperator;
+declare function isTSTypeOperator<Opts extends Options$2<TSTypeOperator>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeOperator & Opts;
+declare function isTSIndexedAccessType(node: Node$1 | null | undefined): node is TSIndexedAccessType;
+declare function isTSIndexedAccessType<Opts extends Options$2<TSIndexedAccessType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSIndexedAccessType & Opts;
+declare function isTSMappedType(node: Node$1 | null | undefined): node is TSMappedType;
+declare function isTSMappedType<Opts extends Options$2<TSMappedType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSMappedType & Opts;
+declare function isTSTemplateLiteralType(node: Node$1 | null | undefined): node is TSTemplateLiteralType;
+declare function isTSTemplateLiteralType<Opts extends Options$2<TSTemplateLiteralType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTemplateLiteralType & Opts;
+declare function isTSLiteralType(node: Node$1 | null | undefined): node is TSLiteralType;
+declare function isTSLiteralType<Opts extends Options$2<TSLiteralType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSLiteralType & Opts;
+declare function isTSExpressionWithTypeArguments(node: Node$1 | null | undefined): node is TSExpressionWithTypeArguments;
+declare function isTSExpressionWithTypeArguments<Opts extends Options$2<TSExpressionWithTypeArguments>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSExpressionWithTypeArguments & Opts;
+declare function isTSInterfaceDeclaration(node: Node$1 | null | undefined): node is TSInterfaceDeclaration;
+declare function isTSInterfaceDeclaration<Opts extends Options$2<TSInterfaceDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSInterfaceDeclaration & Opts;
+declare function isTSInterfaceBody(node: Node$1 | null | undefined): node is TSInterfaceBody;
+declare function isTSInterfaceBody<Opts extends Options$2<TSInterfaceBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSInterfaceBody & Opts;
+declare function isTSTypeAliasDeclaration(node: Node$1 | null | undefined): node is TSTypeAliasDeclaration;
+declare function isTSTypeAliasDeclaration<Opts extends Options$2<TSTypeAliasDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeAliasDeclaration & Opts;
+declare function isTSInstantiationExpression(node: Node$1 | null | undefined): node is TSInstantiationExpression;
+declare function isTSInstantiationExpression<Opts extends Options$2<TSInstantiationExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSInstantiationExpression & Opts;
+declare function isTSAsExpression(node: Node$1 | null | undefined): node is TSAsExpression;
+declare function isTSAsExpression<Opts extends Options$2<TSAsExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSAsExpression & Opts;
+declare function isTSSatisfiesExpression(node: Node$1 | null | undefined): node is TSSatisfiesExpression;
+declare function isTSSatisfiesExpression<Opts extends Options$2<TSSatisfiesExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSSatisfiesExpression & Opts;
+declare function isTSTypeAssertion(node: Node$1 | null | undefined): node is TSTypeAssertion;
+declare function isTSTypeAssertion<Opts extends Options$2<TSTypeAssertion>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeAssertion & Opts;
+declare function isTSEnumBody(node: Node$1 | null | undefined): node is TSEnumBody;
+declare function isTSEnumBody<Opts extends Options$2<TSEnumBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSEnumBody & Opts;
+declare function isTSEnumDeclaration(node: Node$1 | null | undefined): node is TSEnumDeclaration;
+declare function isTSEnumDeclaration<Opts extends Options$2<TSEnumDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSEnumDeclaration & Opts;
+declare function isTSEnumMember(node: Node$1 | null | undefined): node is TSEnumMember;
+declare function isTSEnumMember<Opts extends Options$2<TSEnumMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSEnumMember & Opts;
+declare function isTSModuleDeclaration(node: Node$1 | null | undefined): node is TSModuleDeclaration;
+declare function isTSModuleDeclaration<Opts extends Options$2<TSModuleDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSModuleDeclaration & Opts;
+declare function isTSModuleBlock(node: Node$1 | null | undefined): node is TSModuleBlock;
+declare function isTSModuleBlock<Opts extends Options$2<TSModuleBlock>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSModuleBlock & Opts;
+declare function isTSImportType(node: Node$1 | null | undefined): node is TSImportType;
+declare function isTSImportType<Opts extends Options$2<TSImportType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSImportType & Opts;
+declare function isTSImportEqualsDeclaration(node: Node$1 | null | undefined): node is TSImportEqualsDeclaration;
+declare function isTSImportEqualsDeclaration<Opts extends Options$2<TSImportEqualsDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSImportEqualsDeclaration & Opts;
+declare function isTSExternalModuleReference(node: Node$1 | null | undefined): node is TSExternalModuleReference;
+declare function isTSExternalModuleReference<Opts extends Options$2<TSExternalModuleReference>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSExternalModuleReference & Opts;
+declare function isTSNonNullExpression(node: Node$1 | null | undefined): node is TSNonNullExpression;
+declare function isTSNonNullExpression<Opts extends Options$2<TSNonNullExpression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNonNullExpression & Opts;
+declare function isTSExportAssignment(node: Node$1 | null | undefined): node is TSExportAssignment;
+declare function isTSExportAssignment<Opts extends Options$2<TSExportAssignment>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSExportAssignment & Opts;
+declare function isTSNamespaceExportDeclaration(node: Node$1 | null | undefined): node is TSNamespaceExportDeclaration;
+declare function isTSNamespaceExportDeclaration<Opts extends Options$2<TSNamespaceExportDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSNamespaceExportDeclaration & Opts;
+declare function isTSTypeAnnotation(node: Node$1 | null | undefined): node is TSTypeAnnotation;
+declare function isTSTypeAnnotation<Opts extends Options$2<TSTypeAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeAnnotation & Opts;
+declare function isTSTypeParameterInstantiation(node: Node$1 | null | undefined): node is TSTypeParameterInstantiation;
+declare function isTSTypeParameterInstantiation<Opts extends Options$2<TSTypeParameterInstantiation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeParameterInstantiation & Opts;
+declare function isTSTypeParameterDeclaration(node: Node$1 | null | undefined): node is TSTypeParameterDeclaration;
+declare function isTSTypeParameterDeclaration<Opts extends Options$2<TSTypeParameterDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeParameterDeclaration & Opts;
+declare function isTSTypeParameter(node: Node$1 | null | undefined): node is TSTypeParameter;
+declare function isTSTypeParameter<Opts extends Options$2<TSTypeParameter>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeParameter & Opts;
+declare function isStandardized(node: Node$1 | null | undefined): node is Standardized;
+declare function isStandardized<Opts extends Options$2<Standardized>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Standardized & Opts;
+declare function isExpression(node: Node$1 | null | undefined): node is Expression;
+declare function isExpression<Opts extends Options$2<Expression>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Expression & Opts;
+declare function isBinary(node: Node$1 | null | undefined): node is Binary;
+declare function isBinary<Opts extends Options$2<Binary>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Binary & Opts;
+declare function isScopable(node: Node$1 | null | undefined): node is Scopable;
+declare function isScopable<Opts extends Options$2<Scopable>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Scopable & Opts;
+declare function isBlockParent(node: Node$1 | null | undefined): node is BlockParent;
+declare function isBlockParent<Opts extends Options$2<BlockParent>>(node: Node$1 | null | undefined, opts?: Opts | null): node is BlockParent & Opts;
+declare function isBlock(node: Node$1 | null | undefined): node is Block;
+declare function isBlock<Opts extends Options$2<Block>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Block & Opts;
+declare function isStatement(node: Node$1 | null | undefined): node is Statement;
+declare function isStatement<Opts extends Options$2<Statement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Statement & Opts;
+declare function isTerminatorless(node: Node$1 | null | undefined): node is Terminatorless;
+declare function isTerminatorless<Opts extends Options$2<Terminatorless>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Terminatorless & Opts;
+declare function isCompletionStatement(node: Node$1 | null | undefined): node is CompletionStatement;
+declare function isCompletionStatement<Opts extends Options$2<CompletionStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is CompletionStatement & Opts;
+declare function isConditional(node: Node$1 | null | undefined): node is Conditional;
+declare function isConditional<Opts extends Options$2<Conditional>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Conditional & Opts;
+declare function isLoop(node: Node$1 | null | undefined): node is Loop;
+declare function isLoop<Opts extends Options$2<Loop>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Loop & Opts;
+declare function isWhile(node: Node$1 | null | undefined): node is While;
+declare function isWhile<Opts extends Options$2<While>>(node: Node$1 | null | undefined, opts?: Opts | null): node is While & Opts;
+declare function isExpressionWrapper(node: Node$1 | null | undefined): node is ExpressionWrapper;
+declare function isExpressionWrapper<Opts extends Options$2<ExpressionWrapper>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExpressionWrapper & Opts;
+declare function isFor(node: Node$1 | null | undefined): node is For;
+declare function isFor<Opts extends Options$2<For>>(node: Node$1 | null | undefined, opts?: Opts | null): node is For & Opts;
+declare function isForXStatement(node: Node$1 | null | undefined): node is ForXStatement;
+declare function isForXStatement<Opts extends Options$2<ForXStatement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ForXStatement & Opts;
+declare function isFunction(node: Node$1 | null | undefined): node is Function;
+declare function isFunction<Opts extends Options$2<Function>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Function & Opts;
+declare function isFunctionParent(node: Node$1 | null | undefined): node is FunctionParent;
+declare function isFunctionParent<Opts extends Options$2<FunctionParent>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionParent & Opts;
+declare function isPureish(node: Node$1 | null | undefined): node is Pureish;
+declare function isPureish<Opts extends Options$2<Pureish>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Pureish & Opts;
+declare function isDeclaration(node: Node$1 | null | undefined): node is Declaration;
+declare function isDeclaration<Opts extends Options$2<Declaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Declaration & Opts;
+declare function isFunctionParameter(node: Node$1 | null | undefined): node is FunctionParameter;
+declare function isFunctionParameter<Opts extends Options$2<FunctionParameter>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FunctionParameter & Opts;
+declare function isPatternLike(node: Node$1 | null | undefined): node is PatternLike;
+declare function isPatternLike<Opts extends Options$2<PatternLike>>(node: Node$1 | null | undefined, opts?: Opts | null): node is PatternLike & Opts;
+declare function isLVal(node: Node$1 | null | undefined): node is LVal;
+declare function isLVal<Opts extends Options$2<LVal>>(node: Node$1 | null | undefined, opts?: Opts | null): node is LVal & Opts;
+declare function isTSEntityName(node: Node$1 | null | undefined): node is TSEntityName;
+declare function isTSEntityName<Opts extends Options$2<TSEntityName>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSEntityName & Opts;
+declare function isLiteral(node: Node$1 | null | undefined): node is Literal;
+declare function isLiteral<Opts extends Options$2<Literal>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Literal & Opts;
+declare function isUserWhitespacable(node: Node$1 | null | undefined): node is UserWhitespacable;
+declare function isUserWhitespacable<Opts extends Options$2<UserWhitespacable>>(node: Node$1 | null | undefined, opts?: Opts | null): node is UserWhitespacable & Opts;
+declare function isMethod(node: Node$1 | null | undefined): node is Method;
+declare function isMethod<Opts extends Options$2<Method>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Method & Opts;
+declare function isObjectMember(node: Node$1 | null | undefined): node is ObjectMember;
+declare function isObjectMember<Opts extends Options$2<ObjectMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ObjectMember & Opts;
+declare function isProperty(node: Node$1 | null | undefined): node is Property;
+declare function isProperty<Opts extends Options$2<Property>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Property & Opts;
+declare function isUnaryLike(node: Node$1 | null | undefined): node is UnaryLike;
+declare function isUnaryLike<Opts extends Options$2<UnaryLike>>(node: Node$1 | null | undefined, opts?: Opts | null): node is UnaryLike & Opts;
+declare function isPattern(node: Node$1 | null | undefined): node is Pattern;
+declare function isPattern<Opts extends Options$2<Pattern>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Pattern & Opts;
+declare function isClass(node: Node$1 | null | undefined): node is Class;
+declare function isClass<Opts extends Options$2<Class>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Class & Opts;
+declare function isImportOrExportDeclaration(node: Node$1 | null | undefined): node is ImportOrExportDeclaration;
+declare function isImportOrExportDeclaration<Opts extends Options$2<ImportOrExportDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts;
+declare function isExportDeclaration(node: Node$1 | null | undefined): node is ExportDeclaration;
+declare function isExportDeclaration<Opts extends Options$2<ExportDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ExportDeclaration & Opts;
+declare function isModuleSpecifier(node: Node$1 | null | undefined): node is ModuleSpecifier;
+declare function isModuleSpecifier<Opts extends Options$2<ModuleSpecifier>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ModuleSpecifier & Opts;
+declare function isAccessor(node: Node$1 | null | undefined): node is Accessor;
+declare function isAccessor<Opts extends Options$2<Accessor>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Accessor & Opts;
+declare function isPrivate(node: Node$1 | null | undefined): node is Private;
+declare function isPrivate<Opts extends Options$2<Private>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Private & Opts;
+declare function isFlow(node: Node$1 | null | undefined): node is Flow;
+declare function isFlow<Opts extends Options$2<Flow>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Flow & Opts;
+declare function isFlowType(node: Node$1 | null | undefined): node is FlowType;
+declare function isFlowType<Opts extends Options$2<FlowType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FlowType & Opts;
+declare function isFlowBaseAnnotation(node: Node$1 | null | undefined): node is FlowBaseAnnotation;
+declare function isFlowBaseAnnotation<Opts extends Options$2<FlowBaseAnnotation>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FlowBaseAnnotation & Opts;
+declare function isFlowDeclaration(node: Node$1 | null | undefined): node is FlowDeclaration;
+declare function isFlowDeclaration<Opts extends Options$2<FlowDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FlowDeclaration & Opts;
+declare function isFlowPredicate(node: Node$1 | null | undefined): node is FlowPredicate;
+declare function isFlowPredicate<Opts extends Options$2<FlowPredicate>>(node: Node$1 | null | undefined, opts?: Opts | null): node is FlowPredicate & Opts;
+declare function isEnumBody(node: Node$1 | null | undefined): node is EnumBody;
+declare function isEnumBody<Opts extends Options$2<EnumBody>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumBody & Opts;
+declare function isEnumMember(node: Node$1 | null | undefined): node is EnumMember;
+declare function isEnumMember<Opts extends Options$2<EnumMember>>(node: Node$1 | null | undefined, opts?: Opts | null): node is EnumMember & Opts;
+declare function isJSX(node: Node$1 | null | undefined): node is JSX;
+declare function isJSX<Opts extends Options$2<JSX>>(node: Node$1 | null | undefined, opts?: Opts | null): node is JSX & Opts;
+declare function isMiscellaneous(node: Node$1 | null | undefined): node is Miscellaneous;
+declare function isMiscellaneous<Opts extends Options$2<Miscellaneous>>(node: Node$1 | null | undefined, opts?: Opts | null): node is Miscellaneous & Opts;
+declare function isTypeScript(node: Node$1 | null | undefined): node is TypeScript;
+declare function isTypeScript<Opts extends Options$2<TypeScript>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TypeScript & Opts;
+declare function isTSTypeElement(node: Node$1 | null | undefined): node is TSTypeElement;
+declare function isTSTypeElement<Opts extends Options$2<TSTypeElement>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSTypeElement & Opts;
+declare function isTSType(node: Node$1 | null | undefined): node is TSType;
+declare function isTSType<Opts extends Options$2<TSType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSType & Opts;
+declare function isTSBaseType(node: Node$1 | null | undefined): node is TSBaseType;
+declare function isTSBaseType<Opts extends Options$2<TSBaseType>>(node: Node$1 | null | undefined, opts?: Opts | null): node is TSBaseType & Opts;
 /**
  * @deprecated Use `isNumericLiteral`
  */
-declare function isNumberLiteral(node: Node$1 | null | undefined, opts?: Opts<NumberLiteral$1> | null): boolean;
+declare function isNumberLiteral(node: Node$1 | null | undefined): boolean;
+declare function isNumberLiteral<Opts extends Options$2<NumberLiteral$1>>(node: Node$1 | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isRegExpLiteral`
  */
-declare function isRegexLiteral(node: Node$1 | null | undefined, opts?: Opts<RegexLiteral$1> | null): boolean;
+declare function isRegexLiteral(node: Node$1 | null | undefined): boolean;
+declare function isRegexLiteral<Opts extends Options$2<RegexLiteral$1>>(node: Node$1 | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isRestElement`
  */
-declare function isRestProperty(node: Node$1 | null | undefined, opts?: Opts<RestProperty$1> | null): boolean;
+declare function isRestProperty(node: Node$1 | null | undefined): boolean;
+declare function isRestProperty<Opts extends Options$2<RestProperty$1>>(node: Node$1 | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isSpreadElement`
  */
-declare function isSpreadProperty(node: Node$1 | null | undefined, opts?: Opts<SpreadProperty$1> | null): boolean;
+declare function isSpreadProperty(node: Node$1 | null | undefined): boolean;
+declare function isSpreadProperty<Opts extends Options$2<SpreadProperty$1>>(node: Node$1 | null | undefined, opts?: Opts | null): boolean;
 /**
  * @deprecated Use `isImportOrExportDeclaration`
  */
-declare function isModuleDeclaration(node: Node$1 | null | undefined, opts?: Opts<ModuleDeclaration> | null): node is ImportOrExportDeclaration;
+declare function isModuleDeclaration<Opts extends Options$2<ModuleDeclaration>>(node: Node$1 | null | undefined, opts?: Opts | null): node is ImportOrExportDeclaration & Opts;
 
 declare function deprecationWarning(oldName: string, newName: string, prefix?: string, cacheKey?: string): void;
 
@@ -4632,6 +4945,26 @@ declare namespace index_d$1 {
 /* eslint-disable @typescript-eslint/consistent-type-imports, @typescript-eslint/no-redundant-type-constituents */
 
 
+declare class Position {
+    line: number;
+    column: number;
+    index: number;
+    constructor(line: number, col: number, index: number);
+}
+
+type SyntaxPlugin = "flow" | "typescript" | "jsx" | "pipelineOperator" | "placeholders";
+type ParseErrorCode = "BABEL_PARSER_SYNTAX_ERROR" | "BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED";
+interface ParseErrorSpecification<ErrorDetails> {
+    code: ParseErrorCode;
+    reasonCode: string;
+    syntaxPlugin?: SyntaxPlugin;
+    missingPlugin?: string | string[];
+    loc: Position;
+    details: ErrorDetails;
+    pos: number;
+}
+type ParseError$1<ErrorDetails> = SyntaxError & ParseErrorSpecification<ErrorDetails>;
+
 type BABEL_8_BREAKING = false;
 type IF_BABEL_7<V> = false extends BABEL_8_BREAKING ? V : never;
 
@@ -4749,6 +5082,10 @@ interface Options {
      * Set this to true to accept such code.
      */
     allowNewTargetOutsideFunction?: boolean;
+    /**
+     * By default, super calls are not allowed outside of a method.
+     * Set this to true to accept such code.
+     */
     allowSuperOutsideMethod?: boolean;
     /**
      * By default, exported identifiers must refer to a declared variable.
@@ -4847,12 +5184,11 @@ interface Options {
 }
 
 type ParserOptions = Partial<Options>;
-interface ParseError {
-    code: string;
-    reasonCode: string;
-}
+type ParseError = ParseError$1<object>;
 type ParseResult$1<Result extends File | Expression = File> = Result & {
+    comments: File["comments"];
     errors: null | ParseError[];
+    tokens?: File["tokens"];
 };
 /**
  * Parse the provided code as an entire ECMAScript program.