declare function interpreterDirective(value: string): InterpreterDirective;


declare function directive(value: DirectiveLiteral): Directive;


declare function directiveLiteral(value: string): DirectiveLiteral;


declare function blockStatement(body: Array<Statement>, directives?: Array<Directive>): BlockStatement;


declare function breakStatement(label?: Identifier | null): BreakStatement;


declare function callExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): CallExpression;


declare function catchClause(param: Identifier | ArrayPattern | ObjectPattern | null | undefined, body: BlockStatement): CatchClause;


declare function conditionalExpression(test: Expression, consequent: Expression, alternate: Expression): ConditionalExpression;


declare function continueStatement(label?: Identifier | null): ContinueStatement;


declare function debuggerStatement(): DebuggerStatement;


declare function doWhileStatement(test: Expression, body: Statement): DoWhileStatement;


declare function emptyStatement(): EmptyStatement;


declare function expressionStatement(expression: Expression): ExpressionStatement;


declare function file(program: Program, comments?: Array<CommentBlock | CommentLine> | null, tokens?: Array<any> | null): File;


declare function forInStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement): ForInStatement;


declare function forStatement(init: VariableDeclaration | Expression | null | undefined, test: Expression | null | undefined, update: Expression | null | undefined, body: Statement): ForStatement;


declare function functionDeclaration(id: Identifier | null | undefined, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionDeclaration;


declare function functionExpression(id: Identifier | null | undefined, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, generator?: boolean, async?: boolean): FunctionExpression;


declare function identifier(name: string): Identifier;


declare function ifStatement(test: Expression, consequent: Statement, alternate?: Statement | null): IfStatement;


declare function labeledStatement(label: Identifier, body: Statement): LabeledStatement;


declare function stringLiteral(value: string): StringLiteral;


declare function numericLiteral(value: number): NumericLiteral;


declare function nullLiteral(): NullLiteral;


declare function booleanLiteral(value: boolean): BooleanLiteral;


declare function regExpLiteral(pattern: string, flags?: string): RegExpLiteral;


declare function logicalExpression(operator: "||" | "&&" | "??", left: Expression, right: Expression): LogicalExpression;


declare function memberExpression(object: Expression, property: Expression | Identifier | PrivateName, computed?: boolean, optional?: true | false | null): MemberExpression;


declare function newExpression(callee: Expression | V8IntrinsicIdentifier, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>): NewExpression;


declare function program(body: Array<Statement>, directives?: Array<Directive>, sourceType?: "script" | "module", interpreter?: InterpreterDirective | null): Program;


declare function objectExpression(properties: Array<ObjectMethod | ObjectProperty | SpreadElement>): ObjectExpression;


declare function objectMethod(kind: "method" | "get" | "set" | undefined, key: Expression | Identifier | StringLiteral | NumericLiteral, params: Array<Identifier | Pattern | RestElement>, body: BlockStatement, computed?: boolean, generator?: boolean, async?: boolean): ObjectMethod;


declare function objectProperty(key: Expression | Identifier | StringLiteral | NumericLiteral, value: Expression | PatternLike, computed?: boolean, shorthand?: boolean, decorators?: Array<Decorator> | null): ObjectProperty;


declare function restElement(argument: LVal): RestElement;


declare function returnStatement(argument?: Expression | null): ReturnStatement;


declare function sequenceExpression(expressions: Array<Expression>): SequenceExpression;


declare function parenthesizedExpression(expression: Expression): ParenthesizedExpression;


declare function switchCase(test: Expression | null | undefined, consequent: Array<Statement>): SwitchCase;


declare function switchStatement(discriminant: Expression, cases: Array<SwitchCase>): SwitchStatement;


declare function thisExpression(): ThisExpression;


declare function throwStatement(argument: Expression): ThrowStatement;


declare function tryStatement(block: BlockStatement, handler?: CatchClause | null, finalizer?: BlockStatement | null): TryStatement;


declare function unaryExpression(operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof", argument: Expression, prefix?: boolean): UnaryExpression;


declare function updateExpression(operator: "++" | "--", argument: Expression, prefix?: boolean): UpdateExpression;


declare function variableDeclaration(kind: "var" | "let" | "const", declarations: Array<VariableDeclarator>): VariableDeclaration;


declare function variableDeclarator(id: LVal, init?: Expression | null): VariableDeclarator;


declare function whileStatement(test: Expression, body: Statement): WhileStatement;


declare function withStatement(object: Expression, body: Statement): WithStatement;


declare function assignmentPattern(left: Identifier | ObjectPattern | ArrayPattern | MemberExpression, right: Expression): AssignmentPattern;


declare function arrayPattern(elements: Array<null | PatternLike>): ArrayPattern;


declare function arrowFunctionExpression(params: Array<Identifier | Pattern | RestElement>, body: BlockStatement | Expression, async?: boolean): ArrowFunctionExpression;


declare function classBody(body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>): ClassBody;


declare function classExpression(id: Identifier | null | undefined, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassExpression;


declare function classDeclaration(id: Identifier, superClass: Expression | null | undefined, body: ClassBody, decorators?: Array<Decorator> | null): ClassDeclaration;


declare function exportAllDeclaration(source: StringLiteral): ExportAllDeclaration;


declare function exportDefaultDeclaration(declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression): ExportDefaultDeclaration;


declare function exportNamedDeclaration(declaration?: Declaration | null, specifiers?: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>, source?: StringLiteral | null): ExportNamedDeclaration;


declare function exportSpecifier(local: Identifier, exported: Identifier | StringLiteral): ExportSpecifier;


declare function forOfStatement(left: VariableDeclaration | LVal, right: Expression, body: Statement, _await?: boolean): ForOfStatement;


declare function importDeclaration(specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>, source: StringLiteral): ImportDeclaration;


declare function importDefaultSpecifier(local: Identifier): ImportDefaultSpecifier;


declare function importNamespaceSpecifier(local: Identifier): ImportNamespaceSpecifier;


declare function importSpecifier(local: Identifier, imported: Identifier | StringLiteral): ImportSpecifier;


declare function metaProperty(meta: Identifier, property: Identifier): MetaProperty;


declare function classMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, computed?: boolean, _static?: boolean, generator?: boolean, async?: boolean): ClassMethod;


declare function objectPattern(properties: Array<RestElement | ObjectProperty>): ObjectPattern;


declare function spreadElement(argument: Expression): SpreadElement;


declare function _super(): Super;


declare function taggedTemplateExpression(tag: Expression, quasi: TemplateLiteral): TaggedTemplateExpression;


declare function templateElement(value: {
    raw: string;
    cooked?: string;
}, tail?: boolean): TemplateElement;


declare function templateLiteral(quasis: Array<TemplateElement>, expressions: Array<Expression | TSType>): TemplateLiteral;


declare function yieldExpression(argument?: Expression | null, delegate?: boolean): YieldExpression;


declare function awaitExpression(argument: Expression): AwaitExpression;


declare function _import(): Import;


declare function bigIntLiteral(value: string): BigIntLiteral;


declare function exportNamespaceSpecifier(exported: Identifier): ExportNamespaceSpecifier;


declare function optionalMemberExpression(object: Expression, property: Expression | Identifier, computed: boolean | undefined, optional: boolean): OptionalMemberExpression;


declare function optionalCallExpression(callee: Expression, _arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>, optional: boolean): OptionalCallExpression;


declare function classProperty(key: Identifier | StringLiteral | NumericLiteral | Expression, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassProperty;


declare function classAccessorProperty(key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName, value?: Expression | null, typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null, decorators?: Array<Decorator> | null, computed?: boolean, _static?: boolean): ClassAccessorProperty;


declare function classPrivateProperty(key: PrivateName, value: Expression | null | undefined, decorators: Array<Decorator> | null | undefined, _static: any): ClassPrivateProperty;


declare function classPrivateMethod(kind: "get" | "set" | "method" | "constructor" | undefined, key: PrivateName, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, body: BlockStatement, _static?: boolean): ClassPrivateMethod;


declare function privateName(id: Identifier): PrivateName;


declare function staticBlock(body: Array<Statement>): StaticBlock;


declare function anyTypeAnnotation(): AnyTypeAnnotation;


declare function arrayTypeAnnotation(elementType: FlowType): ArrayTypeAnnotation;


declare function booleanTypeAnnotation(): BooleanTypeAnnotation;


declare function booleanLiteralTypeAnnotation(value: boolean): BooleanLiteralTypeAnnotation;


declare function nullLiteralTypeAnnotation(): NullLiteralTypeAnnotation;


declare function classImplements(id: Identifier, typeParameters?: TypeParameterInstantiation | null): ClassImplements;


declare function declareClass(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareClass;


declare function declareFunction(id: Identifier): DeclareFunction;


declare function declareInterface(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): DeclareInterface;


declare function declareModule(id: Identifier | StringLiteral, body: BlockStatement, kind?: "CommonJS" | "ES" | null): DeclareModule;


declare function declareModuleExports(typeAnnotation: TypeAnnotation): DeclareModuleExports;


declare function declareTypeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): DeclareTypeAlias;


declare function declareOpaqueType(id: Identifier, typeParameters?: TypeParameterDeclaration | null, supertype?: FlowType | null): DeclareOpaqueType;


declare function declareVariable(id: Identifier): DeclareVariable;


declare function declareExportDeclaration(declaration?: Flow | null, specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null, source?: StringLiteral | null): DeclareExportDeclaration;


declare function declareExportAllDeclaration(source: StringLiteral): DeclareExportAllDeclaration;


declare function declaredPredicate(value: Flow): DeclaredPredicate;


declare function existsTypeAnnotation(): ExistsTypeAnnotation;


declare function functionTypeAnnotation(typeParameters: TypeParameterDeclaration | null | undefined, params: Array<FunctionTypeParam>, rest: FunctionTypeParam | null | undefined, returnType: FlowType): FunctionTypeAnnotation;


declare function functionTypeParam(name: Identifier | null | undefined, typeAnnotation: FlowType): FunctionTypeParam;


declare function genericTypeAnnotation(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): GenericTypeAnnotation;


declare function inferredPredicate(): InferredPredicate;


declare function interfaceExtends(id: Identifier | QualifiedTypeIdentifier, typeParameters?: TypeParameterInstantiation | null): InterfaceExtends;


declare function interfaceDeclaration(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, _extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceDeclaration;


declare function interfaceTypeAnnotation(_extends: Array<InterfaceExtends> | null | undefined, body: ObjectTypeAnnotation): InterfaceTypeAnnotation;


declare function intersectionTypeAnnotation(types: Array<FlowType>): IntersectionTypeAnnotation;


declare function mixedTypeAnnotation(): MixedTypeAnnotation;


declare function emptyTypeAnnotation(): EmptyTypeAnnotation;


declare function nullableTypeAnnotation(typeAnnotation: FlowType): NullableTypeAnnotation;


declare function numberLiteralTypeAnnotation(value: number): NumberLiteralTypeAnnotation;


declare function numberTypeAnnotation(): NumberTypeAnnotation;


declare function objectTypeAnnotation(properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>, indexers?: Array<ObjectTypeIndexer> | null, callProperties?: Array<ObjectTypeCallProperty> | null, internalSlots?: Array<ObjectTypeInternalSlot> | null, exact?: boolean): ObjectTypeAnnotation;


declare function objectTypeInternalSlot(id: Identifier, value: FlowType, optional: boolean, _static: boolean, method: boolean): ObjectTypeInternalSlot;


declare function objectTypeCallProperty(value: FlowType): ObjectTypeCallProperty;


declare function objectTypeIndexer(id: Identifier | null | undefined, key: FlowType, value: FlowType, variance?: Variance | null): ObjectTypeIndexer;


declare function objectTypeProperty(key: Identifier | StringLiteral, value: FlowType, variance?: Variance | null): ObjectTypeProperty;


declare function objectTypeSpreadProperty(argument: FlowType): ObjectTypeSpreadProperty;


declare function opaqueType(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, supertype: FlowType | null | undefined, impltype: FlowType): OpaqueType;


declare function qualifiedTypeIdentifier(id: Identifier, qualification: Identifier | QualifiedTypeIdentifier): QualifiedTypeIdentifier;


declare function stringLiteralTypeAnnotation(value: string): StringLiteralTypeAnnotation;


declare function stringTypeAnnotation(): StringTypeAnnotation;


declare function symbolTypeAnnotation(): SymbolTypeAnnotation;


declare function thisTypeAnnotation(): ThisTypeAnnotation;


declare function tupleTypeAnnotation(types: Array<FlowType>): TupleTypeAnnotation;


declare function typeofTypeAnnotation(argument: FlowType): TypeofTypeAnnotation;


declare function typeAlias(id: Identifier, typeParameters: TypeParameterDeclaration | null | undefined, right: FlowType): TypeAlias;


declare function typeAnnotation(typeAnnotation: FlowType): TypeAnnotation;


declare function typeCastExpression(expression: Expression, typeAnnotation: TypeAnnotation): TypeCastExpression;


declare function typeParameter(bound?: TypeAnnotation | null, _default?: FlowType | null, variance?: Variance | null): TypeParameter;


declare function typeParameterDeclaration(params: Array<TypeParameter>): TypeParameterDeclaration;


declare function typeParameterInstantiation(params: Array<FlowType>): TypeParameterInstantiation;


declare function unionTypeAnnotation(types: Array<FlowType>): UnionTypeAnnotation;


declare function variance(kind: "minus" | "plus"): Variance;


declare function voidTypeAnnotation(): VoidTypeAnnotation;


declare function enumDeclaration(id: Identifier, body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody): EnumDeclaration;


declare function enumBooleanBody(members: Array<EnumBooleanMember>): EnumBooleanBody;


declare function enumNumberBody(members: Array<EnumNumberMember>): EnumNumberBody;


declare function enumStringBody(members: Array<EnumStringMember | EnumDefaultedMember>): EnumStringBody;


declare function enumSymbolBody(members: Array<EnumDefaultedMember>): EnumSymbolBody;


declare function enumBooleanMember(id: Identifier): EnumBooleanMember;


declare function enumNumberMember(id: Identifier, init: NumericLiteral): EnumNumberMember;


declare function enumStringMember(id: Identifier, init: StringLiteral): EnumStringMember;


declare function enumDefaultedMember(id: Identifier): EnumDefaultedMember;


declare function indexedAccessType(objectType: FlowType, indexType: FlowType): IndexedAccessType;


declare function optionalIndexedAccessType(objectType: FlowType, indexType: FlowType): OptionalIndexedAccessType;


declare function jsxAttribute(name: JSXIdentifier | JSXNamespacedName, value?: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer | null): JSXAttribute;


declare function jsxClosingElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName): JSXClosingElement;


declare function jsxElement(openingElement: JSXOpeningElement, closingElement: JSXClosingElement | null | undefined, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>, selfClosing?: boolean | null): JSXElement;


declare function jsxEmptyExpression(): JSXEmptyExpression;


declare function jsxExpressionContainer(expression: Expression | JSXEmptyExpression): JSXExpressionContainer;


declare function jsxSpreadChild(expression: Expression): JSXSpreadChild;


declare function jsxIdentifier(name: string): JSXIdentifier;


declare function jsxMemberExpression(object: JSXMemberExpression | JSXIdentifier, property: JSXIdentifier): JSXMemberExpression;


declare function jsxNamespacedName(namespace: JSXIdentifier, name: JSXIdentifier): JSXNamespacedName;


declare function jsxOpeningElement(name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName, attributes: Array<JSXAttribute | JSXSpreadAttribute>, selfClosing?: boolean): JSXOpeningElement;


declare function jsxSpreadAttribute(argument: Expression): JSXSpreadAttribute;


declare function jsxText(value: string): JSXText;


declare function jsxFragment(openingFragment: JSXOpeningFragment, closingFragment: JSXClosingFragment, children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>): JSXFragment;


declare function jsxOpeningFragment(): JSXOpeningFragment;


declare function jsxClosingFragment(): JSXClosingFragment;


declare function noop(): Noop;


declare function placeholder(expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern", name: Identifier): Placeholder;


declare function v8IntrinsicIdentifier(name: string): V8IntrinsicIdentifier;


declare function argumentPlaceholder(): ArgumentPlaceholder;


declare function bindExpression(object: Expression, callee: Expression): BindExpression;


declare function importAttribute(key: Identifier | StringLiteral, value: StringLiteral): ImportAttribute;


declare function decorator(expression: Expression): Decorator;


declare function doExpression(body: BlockStatement, async?: boolean): DoExpression;


declare function exportDefaultSpecifier(exported: Identifier): ExportDefaultSpecifier;


declare function recordExpression(properties: Array<ObjectProperty | SpreadElement>): RecordExpression;


declare function tupleExpression(elements?: Array<Expression | SpreadElement>): TupleExpression;


declare function decimalLiteral(value: string): DecimalLiteral;


declare function moduleExpression(body: Program): ModuleExpression;


declare function topicReference(): TopicReference;


declare function pipelineTopicExpression(expression: Expression): PipelineTopicExpression;


declare function pipelineBareFunction(callee: Expression): PipelineBareFunction;


declare function pipelinePrimaryTopicReference(): PipelinePrimaryTopicReference;


declare function tsParameterProperty(parameter: Identifier | AssignmentPattern): TSParameterProperty;


declare function tsDeclareFunction(id: Identifier | null | undefined, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareFunction;


declare function tsDeclareMethod(decorators: Array<Decorator> | null | undefined, key: Identifier | StringLiteral | NumericLiteral | Expression, typeParameters: TSTypeParameterDeclaration | Noop | null | undefined, params: Array<Identifier | Pattern | RestElement | TSParameterProperty>, returnType?: TSTypeAnnotation | Noop | null): TSDeclareMethod;


declare function tsQualifiedName(left: TSEntityName, right: Identifier): TSQualifiedName;


declare function tsCallSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSCallSignatureDeclaration;


declare function tsConstructSignatureDeclaration(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructSignatureDeclaration;


declare function tsPropertySignature(key: Expression, typeAnnotation?: TSTypeAnnotation | null, initializer?: Expression | null): TSPropertySignature;


declare function tsMethodSignature(key: Expression, typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSMethodSignature;


declare function tsIndexSignature(parameters: Array<Identifier>, typeAnnotation?: TSTypeAnnotation | null): TSIndexSignature;


declare function tsAnyKeyword(): TSAnyKeyword;


declare function tsBooleanKeyword(): TSBooleanKeyword;


declare function tsBigIntKeyword(): TSBigIntKeyword;


declare function tsIntrinsicKeyword(): TSIntrinsicKeyword;


declare function tsNeverKeyword(): TSNeverKeyword;


declare function tsNullKeyword(): TSNullKeyword;


declare function tsNumberKeyword(): TSNumberKeyword;


declare function tsObjectKeyword(): TSObjectKeyword;


declare function tsStringKeyword(): TSStringKeyword;


declare function tsSymbolKeyword(): TSSymbolKeyword;


declare function tsUndefinedKeyword(): TSUndefinedKeyword;


declare function tsUnknownKeyword(): TSUnknownKeyword;


declare function tsVoidKeyword(): TSVoidKeyword;


declare function tsThisType(): TSThisType;


declare function tsFunctionType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSFunctionType;


declare function tsConstructorType(typeParameters: TSTypeParameterDeclaration | null | undefined, parameters: Array<Identifier | RestElement>, typeAnnotation?: TSTypeAnnotation | null): TSConstructorType;


declare function tsTypeReference(typeName: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSTypeReference;


declare function tsTypePredicate(parameterName: Identifier | TSThisType, typeAnnotation?: TSTypeAnnotation | null, asserts?: boolean | null): TSTypePredicate;


declare function tsTypeQuery(exprName: TSEntityName | TSImportType): TSTypeQuery;


declare function tsTypeLiteral(members: Array<TSTypeElement>): TSTypeLiteral;


declare function tsArrayType(elementType: TSType): TSArrayType;


declare function tsTupleType(elementTypes: Array<TSType | TSNamedTupleMember>): TSTupleType;


declare function tsOptionalType(typeAnnotation: TSType): TSOptionalType;


declare function tsRestType(typeAnnotation: TSType): TSRestType;


declare function tsNamedTupleMember(label: Identifier, elementType: TSType, optional?: boolean): TSNamedTupleMember;


declare function tsUnionType(types: Array<TSType>): TSUnionType;


declare function tsIntersectionType(types: Array<TSType>): TSIntersectionType;


declare function tsConditionalType(checkType: TSType, extendsType: TSType, trueType: TSType, falseType: TSType): TSConditionalType;


declare function tsInferType(typeParameter: TSTypeParameter): TSInferType;


declare function tsParenthesizedType(typeAnnotation: TSType): TSParenthesizedType;


declare function tsTypeOperator(typeAnnotation: TSType): TSTypeOperator;


declare function tsIndexedAccessType(objectType: TSType, indexType: TSType): TSIndexedAccessType;


declare function tsMappedType(typeParameter: TSTypeParameter, typeAnnotation?: TSType | null, nameType?: TSType | null): TSMappedType;


declare function tsLiteralType(literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | UnaryExpression): TSLiteralType;


declare function tsExpressionWithTypeArguments(expression: TSEntityName, typeParameters?: TSTypeParameterInstantiation | null): TSExpressionWithTypeArguments;


declare function tsInterfaceDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, _extends: Array<TSExpressionWithTypeArguments> | null | undefined, body: TSInterfaceBody): TSInterfaceDeclaration;


declare function tsInterfaceBody(body: Array<TSTypeElement>): TSInterfaceBody;


declare function tsTypeAliasDeclaration(id: Identifier, typeParameters: TSTypeParameterDeclaration | null | undefined, typeAnnotation: TSType): TSTypeAliasDeclaration;


declare function tsAsExpression(expression: Expression, typeAnnotation: TSType): TSAsExpression;


declare function tsTypeAssertion(typeAnnotation: TSType, expression: Expression): TSTypeAssertion;


declare function tsEnumDeclaration(id: Identifier, members: Array<TSEnumMember>): TSEnumDeclaration;


declare function tsEnumMember(id: Identifier | StringLiteral, initializer?: Expression | null): TSEnumMember;


declare function tsModuleDeclaration(id: Identifier | StringLiteral, body: TSModuleBlock | TSModuleDeclaration): TSModuleDeclaration;


declare function tsModuleBlock(body: Array<Statement>): TSModuleBlock;


declare function tsImportType(argument: StringLiteral, qualifier?: TSEntityName | null, typeParameters?: TSTypeParameterInstantiation | null): TSImportType;


declare function tsImportEqualsDeclaration(id: Identifier, moduleReference: TSEntityName | TSExternalModuleReference): TSImportEqualsDeclaration;


declare function tsExternalModuleReference(expression: StringLiteral): TSExternalModuleReference;


declare function tsNonNullExpression(expression: Expression): TSNonNullExpression;


declare function tsExportAssignment(expression: Expression): TSExportAssignment;


declare function tsNamespaceExportDeclaration(id: Identifier): TSNamespaceExportDeclaration;


declare function tsTypeAnnotation(typeAnnotation: TSType): TSTypeAnnotation;


declare function tsTypeParameterInstantiation(params: Array<TSType>): TSTypeParameterInstantiation;


declare function tsTypeParameterDeclaration(params: Array<TSTypeParameter>): TSTypeParameterDeclaration;


declare function tsTypeParameter(constraint: TSType | null | undefined, _default: TSType | null | undefined, name: string): TSTypeParameter;


/** @deprecated */
declare function NumberLiteral(value: number): NumberLiteral$1;


/** @deprecated */
declare function RegexLiteral(pattern: string, flags?: string): RegexLiteral$1;


/** @deprecated */
declare function RestProperty(argument: LVal): RestProperty$1;


/** @deprecated */
declare function SpreadProperty(argument: Expression): SpreadProperty$1;


/**
 * Create a clone of a `node` including only properties belonging to the node.
 * If the second parameter is `false`, cloneNode performs a shallow clone.
 * If the third parameter is true, the cloned nodes exclude location properties.
 */
declare function cloneNode<T extends Node>(node: T, deep?: boolean, withoutLoc?: boolean): T;


/**
 * Create a shallow clone of a `node`, including only
 * properties belonging to the node.
 * @deprecated Use t.cloneNode instead.
 */
declare function clone<T extends Node>(node: T): T;


/**
 * Create a deep clone of a `node` and all of it's child nodes
 * including only properties belonging to the node.
 * @deprecated Use t.cloneNode instead.
 */
declare function cloneDeep<T extends Node>(node: T): T;


/**
 * Create a deep clone of a `node` and all of it's child nodes
 * including only properties belonging to the node.
 * excluding `_private` and location properties.
 */
declare function cloneDeepWithoutLoc<T extends Node>(node: T): T;


/**
 * Create a shallow clone of a `node` excluding `_private` and location properties.
 */
declare function cloneWithoutLoc<T extends Node>(node: T): T;


/**
 * Add comment of certain type to a node.
 */
declare function addComment<T extends Node>(node: T, type: CommentTypeShorthand, content: string, line?: boolean): T;


/**
 * Add comments of certain type to a node.
 */
declare function addComments<T extends Node>(node: T, type: CommentTypeShorthand, comments: ReadonlyArray<Comment>): T;


declare function inheritInnerComments(child: Node, parent: Node): void;


declare function inheritLeadingComments(child: Node, parent: Node): void;


/**
 * Inherit all unique comments from `parent` node to `child` node.
 */
declare function inheritsComments<T extends Node>(child: T, parent: Node): T;


declare function inheritTrailingComments(child: Node, parent: Node): void;


/**
 * Remove comment properties from a node.
 */
declare function removeComments<T extends Node>(node: T): T;


/**
 * Ensure the `key` (defaults to "body") of a `node` is a block.
 * Casting it to a block if it is not.
 *
 * Returns the BlockStatement
 */
declare function ensureBlock(node: Node, key?: string): BlockStatement;


declare function toBindingIdentifierName(name: string): string;


declare function toBlock(node: Statement | Expression, parent?: Node): BlockStatement;


declare function toComputedKey(node: ObjectMember | ObjectProperty | ClassMethod | ClassProperty | ClassAccessorProperty | MemberExpression | OptionalMemberExpression, key?: Expression): Expression;


//# sourceMappingURL=toExpression.d.ts.map
declare function toIdentifier(input: string): string;


declare function toKeyAlias(node: Method | Property, key?: Node): string;


/**
 * Turn an array of statement `nodes` into a `SequenceExpression`.
 *
 * Variable declarations are turned into simple assignments and their
 * declarations hoisted to the top of the current scope.
 *
 * Expression statements are just resolved to their expression.
 */
declare function toSequenceExpression(nodes: ReadonlyArray<Node>, scope: Scope): SequenceExpression | undefined;


//# sourceMappingURL=index.d.ts.map
/**
 * Append a node to a member expression.
 */
declare function appendToMemberExpression(member: MemberExpression, append: MemberExpression["property"], computed?: boolean): MemberExpression;


/**
 * Inherit all contextual properties from `parent` node to `child` node.
 */
declare function inherits<T extends Node | null | undefined>(child: T, parent: Node | null | undefined): T;


/**
 * Prepend a node to a member expression.
 */
declare function prependToMemberExpression<T extends Pick<MemberExpression, "object" | "property">>(member: T, prepend: MemberExpression["object"]): T;


/**
 * Remove all of the _* properties from a node along with the additional metadata
 * properties like location data and raw token data.
 */
declare function removeProperties(node: Node, opts?: {
    preserveComments?: boolean;
}): void;


declare function removePropertiesDeep<T extends Node>(tree: T, opts?: {
    preserveComments: boolean;
} | null): T;


/**
 * Dedupe type annotations.
 */
declare function removeTypeDuplicates(nodes: ReadonlyArray<FlowType | false | null | undefined>): FlowType[];


declare function getBindingIdentifiers(node: Node, duplicates: true, outerOnly?: boolean): Record<string, Array<Identifier>>;


declare function getBindingIdentifiers(node: Node, duplicates?: false, outerOnly?: boolean): Record<string, Identifier>;


declare function getBindingIdentifiers(node: Node, duplicates?: boolean, outerOnly?: boolean): Record<string, Identifier> | Record<string, Array<Identifier>>;


/**
 * A general AST traversal with both prefix and postfix handlers, and a
 * state object. Exposes ancestry data to each handler so that more complex
 * AST data can be taken into account.
 */
declare function traverse<T>(node: Node, handlers: TraversalHandler<T> | TraversalHandlers<T>, state?: T): void;


/**
 * A prefix AST traversal implementation meant for simple searching
 * and processing.
 */
declare function traverseFast(node: Node | null | undefined, enter: (node: Node, opts?: any) => void, opts?: any): void;


declare function shallowEqual<T extends object>(actual: object, expected: T): actual is T;


declare function is<T extends Node["type"]>(type: T, node: Node | null | undefined, opts?: undefined): node is Extract<Node, {
    type: T;
}>;


declare function is<T extends Node["type"], P extends Extract<Node, {
    type: T;
}>>(type: T, n: Node | null | undefined, required: Partial<P>): n is P;


declare function is<P extends Node>(type: string, node: Node | null | undefined, opts: Partial<P>): node is P;


declare function is(type: string, node: Node | null | undefined, opts?: Partial<Node>): node is Node;


/**
 * Check if the input `node` is a binding identifier.
 */
declare function isBinding(node: Node, parent: Node, grandparent?: Node): boolean;


/**
 * Check if the input `node` is block scoped.
 */
declare function isBlockScoped(node: Node): boolean;


/**
 * Check if the input `node` is definitely immutable.
 */
declare function isImmutable(node: Node): boolean;


/**
 * Check if the input `node` is a `let` variable declaration.
 */
declare function isLet(node: Node): boolean;


declare function isNode(node: any): node is Node;


/**
 * Check if two nodes are equivalent
 */
declare function isNodesEquivalent<T extends Partial<Node>>(a: T, b: any): b is T;


/**
 * Test if a `placeholderType` is a `targetType` or if `targetType` is an alias of `placeholderType`.
 */
declare function isPlaceholderType(placeholderType: string, targetType: string): boolean;


/**
 * Check if the input `node` is a reference to a bound variable.
 */
declare function isReferenced(node: Node, parent: Node, grandparent?: Node): boolean;


/**
 * Check if the input `node` is a scope.
 */
declare function isScope(node: Node, parent: Node): boolean;


/**
 * Check if the input `specifier` is a `default` import or export.
 */
declare function isSpecifierDefault(specifier: ModuleSpecifier): boolean;


declare function isType<T extends Node["type"]>(nodeType: string, targetType: T): nodeType is T;


declare function isType(nodeType: string | null | undefined, targetType: string): boolean;


/**
 * Check if the input `name` is a valid identifier name according to the ES3 specification.
 *
 * Additional ES3 reserved words are
 */
declare function isValidES3Identifier(name: string): boolean;


/**
 * Check if the input `name` is a valid identifier name
 * and isn't a reserved word.
 */
declare function isValidIdentifier(name: string, reserved?: boolean): boolean;


/**
 * Check if the input `node` is a variable declaration.
 */
declare function isVar(node: Node): boolean;


/**
 * Determines whether or not the input node `member` matches the
 * input `match`.
 *
 * For example, given the match `React.createClass` it would match the
 * parsed nodes of `React.createClass` and `React["createClass"]`.
 */
declare function matchesPattern(member: Node | null | undefined, match: string | string[], allowPartial?: boolean): boolean;


declare function validate(node: Node | undefined | null, key: string, val: any): void;


/**
 * Build a function that when called will return whether or not the
 * input `node` `MemberExpression` matches the input `match`.
 *
 * For example, given the match `React.createClass` it would match the
 * parsed nodes of `React.createClass` and `React["createClass"]`.
 */
declare function buildMatchMemberExpression(match: string, allowPartial?: boolean): (member: Node) => boolean;


declare function isArrayExpression(node: object | null | undefined, opts?: object | null): node is ArrayExpression;


declare function isAssignmentExpression(node: object | null | undefined, opts?: object | null): node is AssignmentExpression;


declare function isBinaryExpression(node: object | null | undefined, opts?: object | null): node is BinaryExpression;


declare function isInterpreterDirective(node: object | null | undefined, opts?: object | null): node is InterpreterDirective;


declare function isDirective(node: object | null | undefined, opts?: object | null): node is Directive;


declare function isDirectiveLiteral(node: object | null | undefined, opts?: object | null): node is DirectiveLiteral;


declare function isBlockStatement(node: object | null | undefined, opts?: object | null): node is BlockStatement;


declare function isBreakStatement(node: object | null | undefined, opts?: object | null): node is BreakStatement;


declare function isCallExpression(node: object | null | undefined, opts?: object | null): node is CallExpression;


declare function isCatchClause(node: object | null | undefined, opts?: object | null): node is CatchClause;


declare function isConditionalExpression(node: object | null | undefined, opts?: object | null): node is ConditionalExpression;


declare function isContinueStatement(node: object | null | undefined, opts?: object | null): node is ContinueStatement;


declare function isDebuggerStatement(node: object | null | undefined, opts?: object | null): node is DebuggerStatement;


declare function isDoWhileStatement(node: object | null | undefined, opts?: object | null): node is DoWhileStatement;


declare function isEmptyStatement(node: object | null | undefined, opts?: object | null): node is EmptyStatement;


declare function isExpressionStatement(node: object | null | undefined, opts?: object | null): node is ExpressionStatement;


declare function isFile(node: object | null | undefined, opts?: object | null): node is File;


declare function isForInStatement(node: object | null | undefined, opts?: object | null): node is ForInStatement;


declare function isForStatement(node: object | null | undefined, opts?: object | null): node is ForStatement;


declare function isFunctionDeclaration(node: object | null | undefined, opts?: object | null): node is FunctionDeclaration;


declare function isFunctionExpression(node: object | null | undefined, opts?: object | null): node is FunctionExpression;


declare function isIdentifier(node: object | null | undefined, opts?: object | null): node is Identifier;


declare function isIfStatement(node: object | null | undefined, opts?: object | null): node is IfStatement;


declare function isLabeledStatement(node: object | null | undefined, opts?: object | null): node is LabeledStatement;


declare function isStringLiteral(node: object | null | undefined, opts?: object | null): node is StringLiteral;


declare function isNumericLiteral(node: object | null | undefined, opts?: object | null): node is NumericLiteral;


declare function isNullLiteral(node: object | null | undefined, opts?: object | null): node is NullLiteral;


declare function isBooleanLiteral(node: object | null | undefined, opts?: object | null): node is BooleanLiteral;


declare function isRegExpLiteral(node: object | null | undefined, opts?: object | null): node is RegExpLiteral;


declare function isLogicalExpression(node: object | null | undefined, opts?: object | null): node is LogicalExpression;


declare function isMemberExpression(node: object | null | undefined, opts?: object | null): node is MemberExpression;


declare function isNewExpression(node: object | null | undefined, opts?: object | null): node is NewExpression;


declare function isProgram(node: object | null | undefined, opts?: object | null): node is Program;


declare function isObjectExpression(node: object | null | undefined, opts?: object | null): node is ObjectExpression;


declare function isObjectMethod(node: object | null | undefined, opts?: object | null): node is ObjectMethod;


declare function isObjectProperty(node: object | null | undefined, opts?: object | null): node is ObjectProperty;


declare function isRestElement(node: object | null | undefined, opts?: object | null): node is RestElement;


declare function isReturnStatement(node: object | null | undefined, opts?: object | null): node is ReturnStatement;


declare function isSequenceExpression(node: object | null | undefined, opts?: object | null): node is SequenceExpression;


declare function isParenthesizedExpression(node: object | null | undefined, opts?: object | null): node is ParenthesizedExpression;


declare function isSwitchCase(node: object | null | undefined, opts?: object | null): node is SwitchCase;


declare function isSwitchStatement(node: object | null | undefined, opts?: object | null): node is SwitchStatement;


declare function isThisExpression(node: object | null | undefined, opts?: object | null): node is ThisExpression;


declare function isThrowStatement(node: object | null | undefined, opts?: object | null): node is ThrowStatement;


declare function isTryStatement(node: object | null | undefined, opts?: object | null): node is TryStatement;


declare function isUnaryExpression(node: object | null | undefined, opts?: object | null): node is UnaryExpression;


declare function isUpdateExpression(node: object | null | undefined, opts?: object | null): node is UpdateExpression;


declare function isVariableDeclaration(node: object | null | undefined, opts?: object | null): node is VariableDeclaration;


declare function isVariableDeclarator(node: object | null | undefined, opts?: object | null): node is VariableDeclarator;


declare function isWhileStatement(node: object | null | undefined, opts?: object | null): node is WhileStatement;


declare function isWithStatement(node: object | null | undefined, opts?: object | null): node is WithStatement;


declare function isAssignmentPattern(node: object | null | undefined, opts?: object | null): node is AssignmentPattern;


declare function isArrayPattern(node: object | null | undefined, opts?: object | null): node is ArrayPattern;


declare function isArrowFunctionExpression(node: object | null | undefined, opts?: object | null): node is ArrowFunctionExpression;


declare function isClassBody(node: object | null | undefined, opts?: object | null): node is ClassBody;


declare function isClassExpression(node: object | null | undefined, opts?: object | null): node is ClassExpression;


declare function isClassDeclaration(node: object | null | undefined, opts?: object | null): node is ClassDeclaration;


declare function isExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is ExportAllDeclaration;


declare function isExportDefaultDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDefaultDeclaration;


declare function isExportNamedDeclaration(node: object | null | undefined, opts?: object | null): node is ExportNamedDeclaration;


declare function isExportSpecifier(node: object | null | undefined, opts?: object | null): node is ExportSpecifier;


declare function isForOfStatement(node: object | null | undefined, opts?: object | null): node is ForOfStatement;


declare function isImportDeclaration(node: object | null | undefined, opts?: object | null): node is ImportDeclaration;


declare function isImportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ImportDefaultSpecifier;


declare function isImportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ImportNamespaceSpecifier;


declare function isImportSpecifier(node: object | null | undefined, opts?: object | null): node is ImportSpecifier;


declare function isMetaProperty(node: object | null | undefined, opts?: object | null): node is MetaProperty;


declare function isClassMethod(node: object | null | undefined, opts?: object | null): node is ClassMethod;


declare function isObjectPattern(node: object | null | undefined, opts?: object | null): node is ObjectPattern;


declare function isSpreadElement(node: object | null | undefined, opts?: object | null): node is SpreadElement;


declare function isSuper(node: object | null | undefined, opts?: object | null): node is Super;


declare function isTaggedTemplateExpression(node: object | null | undefined, opts?: object | null): node is TaggedTemplateExpression;


declare function isTemplateElement(node: object | null | undefined, opts?: object | null): node is TemplateElement;


declare function isTemplateLiteral(node: object | null | undefined, opts?: object | null): node is TemplateLiteral;


declare function isYieldExpression(node: object | null | undefined, opts?: object | null): node is YieldExpression;


declare function isAwaitExpression(node: object | null | undefined, opts?: object | null): node is AwaitExpression;


declare function isImport(node: object | null | undefined, opts?: object | null): node is Import;


declare function isBigIntLiteral(node: object | null | undefined, opts?: object | null): node is BigIntLiteral;


declare function isExportNamespaceSpecifier(node: object | null | undefined, opts?: object | null): node is ExportNamespaceSpecifier;


declare function isOptionalMemberExpression(node: object | null | undefined, opts?: object | null): node is OptionalMemberExpression;


declare function isOptionalCallExpression(node: object | null | undefined, opts?: object | null): node is OptionalCallExpression;


declare function isClassProperty(node: object | null | undefined, opts?: object | null): node is ClassProperty;


declare function isClassAccessorProperty(node: object | null | undefined, opts?: object | null): node is ClassAccessorProperty;


declare function isClassPrivateProperty(node: object | null | undefined, opts?: object | null): node is ClassPrivateProperty;


declare function isClassPrivateMethod(node: object | null | undefined, opts?: object | null): node is ClassPrivateMethod;


declare function isPrivateName(node: object | null | undefined, opts?: object | null): node is PrivateName;


declare function isStaticBlock(node: object | null | undefined, opts?: object | null): node is StaticBlock;


declare function isAnyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is AnyTypeAnnotation;


declare function isArrayTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ArrayTypeAnnotation;


declare function isBooleanTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanTypeAnnotation;


declare function isBooleanLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is BooleanLiteralTypeAnnotation;


declare function isNullLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullLiteralTypeAnnotation;


declare function isClassImplements(node: object | null | undefined, opts?: object | null): node is ClassImplements;


declare function isDeclareClass(node: object | null | undefined, opts?: object | null): node is DeclareClass;


declare function isDeclareFunction(node: object | null | undefined, opts?: object | null): node is DeclareFunction;


declare function isDeclareInterface(node: object | null | undefined, opts?: object | null): node is DeclareInterface;


declare function isDeclareModule(node: object | null | undefined, opts?: object | null): node is DeclareModule;


declare function isDeclareModuleExports(node: object | null | undefined, opts?: object | null): node is DeclareModuleExports;


declare function isDeclareTypeAlias(node: object | null | undefined, opts?: object | null): node is DeclareTypeAlias;


declare function isDeclareOpaqueType(node: object | null | undefined, opts?: object | null): node is DeclareOpaqueType;


declare function isDeclareVariable(node: object | null | undefined, opts?: object | null): node is DeclareVariable;


declare function isDeclareExportDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportDeclaration;


declare function isDeclareExportAllDeclaration(node: object | null | undefined, opts?: object | null): node is DeclareExportAllDeclaration;


declare function isDeclaredPredicate(node: object | null | undefined, opts?: object | null): node is DeclaredPredicate;


declare function isExistsTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ExistsTypeAnnotation;


declare function isFunctionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is FunctionTypeAnnotation;


declare function isFunctionTypeParam(node: object | null | undefined, opts?: object | null): node is FunctionTypeParam;


declare function isGenericTypeAnnotation(node: object | null | undefined, opts?: object | null): node is GenericTypeAnnotation;


declare function isInferredPredicate(node: object | null | undefined, opts?: object | null): node is InferredPredicate;


declare function isInterfaceExtends(node: object | null | undefined, opts?: object | null): node is InterfaceExtends;


declare function isInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is InterfaceDeclaration;


declare function isInterfaceTypeAnnotation(node: object | null | undefined, opts?: object | null): node is InterfaceTypeAnnotation;


declare function isIntersectionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is IntersectionTypeAnnotation;


declare function isMixedTypeAnnotation(node: object | null | undefined, opts?: object | null): node is MixedTypeAnnotation;


declare function isEmptyTypeAnnotation(node: object | null | undefined, opts?: object | null): node is EmptyTypeAnnotation;


declare function isNullableTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NullableTypeAnnotation;


declare function isNumberLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberLiteralTypeAnnotation;


declare function isNumberTypeAnnotation(node: object | null | undefined, opts?: object | null): node is NumberTypeAnnotation;


declare function isObjectTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ObjectTypeAnnotation;


declare function isObjectTypeInternalSlot(node: object | null | undefined, opts?: object | null): node is ObjectTypeInternalSlot;


declare function isObjectTypeCallProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeCallProperty;


declare function isObjectTypeIndexer(node: object | null | undefined, opts?: object | null): node is ObjectTypeIndexer;


declare function isObjectTypeProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeProperty;


declare function isObjectTypeSpreadProperty(node: object | null | undefined, opts?: object | null): node is ObjectTypeSpreadProperty;


declare function isOpaqueType(node: object | null | undefined, opts?: object | null): node is OpaqueType;


declare function isQualifiedTypeIdentifier(node: object | null | undefined, opts?: object | null): node is QualifiedTypeIdentifier;


declare function isStringLiteralTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringLiteralTypeAnnotation;


declare function isStringTypeAnnotation(node: object | null | undefined, opts?: object | null): node is StringTypeAnnotation;


declare function isSymbolTypeAnnotation(node: object | null | undefined, opts?: object | null): node is SymbolTypeAnnotation;


declare function isThisTypeAnnotation(node: object | null | undefined, opts?: object | null): node is ThisTypeAnnotation;


declare function isTupleTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TupleTypeAnnotation;


declare function isTypeofTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeofTypeAnnotation;


declare function isTypeAlias(node: object | null | undefined, opts?: object | null): node is TypeAlias;


declare function isTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TypeAnnotation;


declare function isTypeCastExpression(node: object | null | undefined, opts?: object | null): node is TypeCastExpression;


declare function isTypeParameter(node: object | null | undefined, opts?: object | null): node is TypeParameter;


declare function isTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TypeParameterDeclaration;


declare function isTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TypeParameterInstantiation;


declare function isUnionTypeAnnotation(node: object | null | undefined, opts?: object | null): node is UnionTypeAnnotation;


declare function isVariance(node: object | null | undefined, opts?: object | null): node is Variance;


declare function isVoidTypeAnnotation(node: object | null | undefined, opts?: object | null): node is VoidTypeAnnotation;


declare function isEnumDeclaration(node: object | null | undefined, opts?: object | null): node is EnumDeclaration;


declare function isEnumBooleanBody(node: object | null | undefined, opts?: object | null): node is EnumBooleanBody;


declare function isEnumNumberBody(node: object | null | undefined, opts?: object | null): node is EnumNumberBody;


declare function isEnumStringBody(node: object | null | undefined, opts?: object | null): node is EnumStringBody;


declare function isEnumSymbolBody(node: object | null | undefined, opts?: object | null): node is EnumSymbolBody;


declare function isEnumBooleanMember(node: object | null | undefined, opts?: object | null): node is EnumBooleanMember;


declare function isEnumNumberMember(node: object | null | undefined, opts?: object | null): node is EnumNumberMember;


declare function isEnumStringMember(node: object | null | undefined, opts?: object | null): node is EnumStringMember;


declare function isEnumDefaultedMember(node: object | null | undefined, opts?: object | null): node is EnumDefaultedMember;


declare function isIndexedAccessType(node: object | null | undefined, opts?: object | null): node is IndexedAccessType;


declare function isOptionalIndexedAccessType(node: object | null | undefined, opts?: object | null): node is OptionalIndexedAccessType;


declare function isJSXAttribute(node: object | null | undefined, opts?: object | null): node is JSXAttribute;


declare function isJSXClosingElement(node: object | null | undefined, opts?: object | null): node is JSXClosingElement;


declare function isJSXElement(node: object | null | undefined, opts?: object | null): node is JSXElement;


declare function isJSXEmptyExpression(node: object | null | undefined, opts?: object | null): node is JSXEmptyExpression;


declare function isJSXExpressionContainer(node: object | null | undefined, opts?: object | null): node is JSXExpressionContainer;


declare function isJSXSpreadChild(node: object | null | undefined, opts?: object | null): node is JSXSpreadChild;


declare function isJSXIdentifier(node: object | null | undefined, opts?: object | null): node is JSXIdentifier;


declare function isJSXMemberExpression(node: object | null | undefined, opts?: object | null): node is JSXMemberExpression;


declare function isJSXNamespacedName(node: object | null | undefined, opts?: object | null): node is JSXNamespacedName;


declare function isJSXOpeningElement(node: object | null | undefined, opts?: object | null): node is JSXOpeningElement;


declare function isJSXSpreadAttribute(node: object | null | undefined, opts?: object | null): node is JSXSpreadAttribute;


declare function isJSXText(node: object | null | undefined, opts?: object | null): node is JSXText;


declare function isJSXFragment(node: object | null | undefined, opts?: object | null): node is JSXFragment;


declare function isJSXOpeningFragment(node: object | null | undefined, opts?: object | null): node is JSXOpeningFragment;


declare function isJSXClosingFragment(node: object | null | undefined, opts?: object | null): node is JSXClosingFragment;


declare function isNoop(node: object | null | undefined, opts?: object | null): node is Noop;


declare function isPlaceholder(node: object | null | undefined, opts?: object | null): node is Placeholder;


declare function isV8IntrinsicIdentifier(node: object | null | undefined, opts?: object | null): node is V8IntrinsicIdentifier;


declare function isArgumentPlaceholder(node: object | null | undefined, opts?: object | null): node is ArgumentPlaceholder;


declare function isBindExpression(node: object | null | undefined, opts?: object | null): node is BindExpression;


declare function isImportAttribute(node: object | null | undefined, opts?: object | null): node is ImportAttribute;


declare function isDecorator(node: object | null | undefined, opts?: object | null): node is Decorator;


declare function isDoExpression(node: object | null | undefined, opts?: object | null): node is DoExpression;


declare function isExportDefaultSpecifier(node: object | null | undefined, opts?: object | null): node is ExportDefaultSpecifier;


declare function isRecordExpression(node: object | null | undefined, opts?: object | null): node is RecordExpression;


declare function isTupleExpression(node: object | null | undefined, opts?: object | null): node is TupleExpression;


declare function isDecimalLiteral(node: object | null | undefined, opts?: object | null): node is DecimalLiteral;


declare function isModuleExpression(node: object | null | undefined, opts?: object | null): node is ModuleExpression;


declare function isTopicReference(node: object | null | undefined, opts?: object | null): node is TopicReference;


declare function isPipelineTopicExpression(node: object | null | undefined, opts?: object | null): node is PipelineTopicExpression;


declare function isPipelineBareFunction(node: object | null | undefined, opts?: object | null): node is PipelineBareFunction;


declare function isPipelinePrimaryTopicReference(node: object | null | undefined, opts?: object | null): node is PipelinePrimaryTopicReference;


declare function isTSParameterProperty(node: object | null | undefined, opts?: object | null): node is TSParameterProperty;


declare function isTSDeclareFunction(node: object | null | undefined, opts?: object | null): node is TSDeclareFunction;


declare function isTSDeclareMethod(node: object | null | undefined, opts?: object | null): node is TSDeclareMethod;


declare function isTSQualifiedName(node: object | null | undefined, opts?: object | null): node is TSQualifiedName;


declare function isTSCallSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSCallSignatureDeclaration;


declare function isTSConstructSignatureDeclaration(node: object | null | undefined, opts?: object | null): node is TSConstructSignatureDeclaration;


declare function isTSPropertySignature(node: object | null | undefined, opts?: object | null): node is TSPropertySignature;


declare function isTSMethodSignature(node: object | null | undefined, opts?: object | null): node is TSMethodSignature;


declare function isTSIndexSignature(node: object | null | undefined, opts?: object | null): node is TSIndexSignature;


declare function isTSAnyKeyword(node: object | null | undefined, opts?: object | null): node is TSAnyKeyword;


declare function isTSBooleanKeyword(node: object | null | undefined, opts?: object | null): node is TSBooleanKeyword;


declare function isTSBigIntKeyword(node: object | null | undefined, opts?: object | null): node is TSBigIntKeyword;


declare function isTSIntrinsicKeyword(node: object | null | undefined, opts?: object | null): node is TSIntrinsicKeyword;


declare function isTSNeverKeyword(node: object | null | undefined, opts?: object | null): node is TSNeverKeyword;


declare function isTSNullKeyword(node: object | null | undefined, opts?: object | null): node is TSNullKeyword;


declare function isTSNumberKeyword(node: object | null | undefined, opts?: object | null): node is TSNumberKeyword;


declare function isTSObjectKeyword(node: object | null | undefined, opts?: object | null): node is TSObjectKeyword;


declare function isTSStringKeyword(node: object | null | undefined, opts?: object | null): node is TSStringKeyword;


declare function isTSSymbolKeyword(node: object | null | undefined, opts?: object | null): node is TSSymbolKeyword;


declare function isTSUndefinedKeyword(node: object | null | undefined, opts?: object | null): node is TSUndefinedKeyword;


declare function isTSUnknownKeyword(node: object | null | undefined, opts?: object | null): node is TSUnknownKeyword;


declare function isTSVoidKeyword(node: object | null | undefined, opts?: object | null): node is TSVoidKeyword;


declare function isTSThisType(node: object | null | undefined, opts?: object | null): node is TSThisType;


declare function isTSFunctionType(node: object | null | undefined, opts?: object | null): node is TSFunctionType;


declare function isTSConstructorType(node: object | null | undefined, opts?: object | null): node is TSConstructorType;


declare function isTSTypeReference(node: object | null | undefined, opts?: object | null): node is TSTypeReference;


declare function isTSTypePredicate(node: object | null | undefined, opts?: object | null): node is TSTypePredicate;


declare function isTSTypeQuery(node: object | null | undefined, opts?: object | null): node is TSTypeQuery;


declare function isTSTypeLiteral(node: object | null | undefined, opts?: object | null): node is TSTypeLiteral;


declare function isTSArrayType(node: object | null | undefined, opts?: object | null): node is TSArrayType;


declare function isTSTupleType(node: object | null | undefined, opts?: object | null): node is TSTupleType;


declare function isTSOptionalType(node: object | null | undefined, opts?: object | null): node is TSOptionalType;


declare function isTSRestType(node: object | null | undefined, opts?: object | null): node is TSRestType;


declare function isTSNamedTupleMember(node: object | null | undefined, opts?: object | null): node is TSNamedTupleMember;


declare function isTSUnionType(node: object | null | undefined, opts?: object | null): node is TSUnionType;


declare function isTSIntersectionType(node: object | null | undefined, opts?: object | null): node is TSIntersectionType;


declare function isTSConditionalType(node: object | null | undefined, opts?: object | null): node is TSConditionalType;


declare function isTSInferType(node: object | null | undefined, opts?: object | null): node is TSInferType;


declare function isTSParenthesizedType(node: object | null | undefined, opts?: object | null): node is TSParenthesizedType;


declare function isTSTypeOperator(node: object | null | undefined, opts?: object | null): node is TSTypeOperator;


declare function isTSIndexedAccessType(node: object | null | undefined, opts?: object | null): node is TSIndexedAccessType;


declare function isTSMappedType(node: object | null | undefined, opts?: object | null): node is TSMappedType;


declare function isTSLiteralType(node: object | null | undefined, opts?: object | null): node is TSLiteralType;


declare function isTSExpressionWithTypeArguments(node: object | null | undefined, opts?: object | null): node is TSExpressionWithTypeArguments;


declare function isTSInterfaceDeclaration(node: object | null | undefined, opts?: object | null): node is TSInterfaceDeclaration;


declare function isTSInterfaceBody(node: object | null | undefined, opts?: object | null): node is TSInterfaceBody;


declare function isTSTypeAliasDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeAliasDeclaration;


declare function isTSAsExpression(node: object | null | undefined, opts?: object | null): node is TSAsExpression;


declare function isTSTypeAssertion(node: object | null | undefined, opts?: object | null): node is TSTypeAssertion;


declare function isTSEnumDeclaration(node: object | null | undefined, opts?: object | null): node is TSEnumDeclaration;


declare function isTSEnumMember(node: object | null | undefined, opts?: object | null): node is TSEnumMember;


declare function isTSModuleDeclaration(node: object | null | undefined, opts?: object | null): node is TSModuleDeclaration;


declare function isTSModuleBlock(node: object | null | undefined, opts?: object | null): node is TSModuleBlock;


declare function isTSImportType(node: object | null | undefined, opts?: object | null): node is TSImportType;


declare function isTSImportEqualsDeclaration(node: object | null | undefined, opts?: object | null): node is TSImportEqualsDeclaration;


declare function isTSExternalModuleReference(node: object | null | undefined, opts?: object | null): node is TSExternalModuleReference;


declare function isTSNonNullExpression(node: object | null | undefined, opts?: object | null): node is TSNonNullExpression;


declare function isTSExportAssignment(node: object | null | undefined, opts?: object | null): node is TSExportAssignment;


declare function isTSNamespaceExportDeclaration(node: object | null | undefined, opts?: object | null): node is TSNamespaceExportDeclaration;


declare function isTSTypeAnnotation(node: object | null | undefined, opts?: object | null): node is TSTypeAnnotation;


declare function isTSTypeParameterInstantiation(node: object | null | undefined, opts?: object | null): node is TSTypeParameterInstantiation;


declare function isTSTypeParameterDeclaration(node: object | null | undefined, opts?: object | null): node is TSTypeParameterDeclaration;


declare function isTSTypeParameter(node: object | null | undefined, opts?: object | null): node is TSTypeParameter;


declare function isStandardized(node: object | null | undefined, opts?: object | null): node is Standardized;


declare function isExpression(node: object | null | undefined, opts?: object | null): node is Expression;


declare function isBinary(node: object | null | undefined, opts?: object | null): node is Binary;


declare function isScopable(node: object | null | undefined, opts?: object | null): node is Scopable;


declare function isBlockParent(node: object | null | undefined, opts?: object | null): node is BlockParent;


declare function isBlock(node: object | null | undefined, opts?: object | null): node is Block;


declare function isStatement(node: object | null | undefined, opts?: object | null): node is Statement;


declare function isTerminatorless(node: object | null | undefined, opts?: object | null): node is Terminatorless;


declare function isCompletionStatement(node: object | null | undefined, opts?: object | null): node is CompletionStatement;


declare function isConditional(node: object | null | undefined, opts?: object | null): node is Conditional;


declare function isLoop(node: object | null | undefined, opts?: object | null): node is Loop;


declare function isWhile(node: object | null | undefined, opts?: object | null): node is While;


declare function isExpressionWrapper(node: object | null | undefined, opts?: object | null): node is ExpressionWrapper;


declare function isFor(node: object | null | undefined, opts?: object | null): node is For;


declare function isForXStatement(node: object | null | undefined, opts?: object | null): node is ForXStatement;


declare function isFunction(node: object | null | undefined, opts?: object | null): node is Function;


declare function isFunctionParent(node: object | null | undefined, opts?: object | null): node is FunctionParent;


declare function isPureish(node: object | null | undefined, opts?: object | null): node is Pureish;


declare function isDeclaration(node: object | null | undefined, opts?: object | null): node is Declaration;


declare function isPatternLike(node: object | null | undefined, opts?: object | null): node is PatternLike;


declare function isLVal(node: object | null | undefined, opts?: object | null): node is LVal;


declare function isTSEntityName(node: object | null | undefined, opts?: object | null): node is TSEntityName;


declare function isLiteral(node: object | null | undefined, opts?: object | null): node is Literal;


declare function isUserWhitespacable(node: object | null | undefined, opts?: object | null): node is UserWhitespacable;


declare function isMethod(node: object | null | undefined, opts?: object | null): node is Method;


declare function isObjectMember(node: object | null | undefined, opts?: object | null): node is ObjectMember;


declare function isProperty(node: object | null | undefined, opts?: object | null): node is Property;


declare function isUnaryLike(node: object | null | undefined, opts?: object | null): node is UnaryLike;


declare function isPattern(node: object | null | undefined, opts?: object | null): node is Pattern;


declare function isClass(node: object | null | undefined, opts?: object | null): node is Class;


declare function isModuleDeclaration(node: object | null | undefined, opts?: object | null): node is ModuleDeclaration;


declare function isExportDeclaration(node: object | null | undefined, opts?: object | null): node is ExportDeclaration;


declare function isModuleSpecifier(node: object | null | undefined, opts?: object | null): node is ModuleSpecifier;


declare function isAccessor(node: object | null | undefined, opts?: object | null): node is Accessor;


declare function isPrivate(node: object | null | undefined, opts?: object | null): node is Private;


declare function isFlow(node: object | null | undefined, opts?: object | null): node is Flow;


declare function isFlowType(node: object | null | undefined, opts?: object | null): node is FlowType;


declare function isFlowBaseAnnotation(node: object | null | undefined, opts?: object | null): node is FlowBaseAnnotation;


declare function isFlowDeclaration(node: object | null | undefined, opts?: object | null): node is FlowDeclaration;


declare function isFlowPredicate(node: object | null | undefined, opts?: object | null): node is FlowPredicate;


declare function isEnumBody(node: object | null | undefined, opts?: object | null): node is EnumBody;


declare function isEnumMember(node: object | null | undefined, opts?: object | null): node is EnumMember;


declare function isJSX(node: object | null | undefined, opts?: object | null): node is JSX;


declare function isMiscellaneous(node: object | null | undefined, opts?: object | null): node is Miscellaneous;


declare function isTypeScript(node: object | null | undefined, opts?: object | null): node is TypeScript;


declare function isTSTypeElement(node: object | null | undefined, opts?: object | null): node is TSTypeElement;


declare function isTSType(node: object | null | undefined, opts?: object | null): node is TSType;


declare function isTSBaseType(node: object | null | undefined, opts?: object | null): node is TSBaseType;


declare function isNumberLiteral(node: object | null | undefined, opts?: object | null): boolean;


declare function isRegexLiteral(node: object | null | undefined, opts?: object | null): boolean;


declare function isRestProperty(node: object | null | undefined, opts?: object | null): boolean;


declare function isSpreadProperty(node: object | null | undefined, opts?: object | null): boolean;


interface BaseComment {
    value: string;
    start: number;
    end: number;
    loc: SourceLocation;
    type: "CommentBlock" | "CommentLine";
}


interface CommentBlock extends BaseComment {
    type: "CommentBlock";
}


interface CommentLine extends BaseComment {
    type: "CommentLine";
}


interface SourceLocation {
    start: {
        line: number;
        column: number;
    };
    end: {
        line: number;
        column: number;
    };
}


interface BaseNode {
    leadingComments: ReadonlyArray<Comment> | null;
    innerComments: ReadonlyArray<Comment> | null;
    trailingComments: ReadonlyArray<Comment> | null;
    start: number | null;
    end: number | null;
    loc: SourceLocation | null;
    type: Node["type"];
    range?: [number, number];
    extra?: Record<string, unknown>;
}


interface ArrayExpression extends BaseNode {
    type: "ArrayExpression";
    elements: Array<null | Expression | SpreadElement>;
}


interface AssignmentExpression extends BaseNode {
    type: "AssignmentExpression";
    operator: string;
    left: LVal;
    right: Expression;
}


interface BinaryExpression extends BaseNode {
    type: "BinaryExpression";
    operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=";
    left: Expression | PrivateName;
    right: Expression;
}


interface InterpreterDirective extends BaseNode {
    type: "InterpreterDirective";
    value: string;
}


interface Directive extends BaseNode {
    type: "Directive";
    value: DirectiveLiteral;
}


interface DirectiveLiteral extends BaseNode {
    type: "DirectiveLiteral";
    value: string;
}


interface BlockStatement extends BaseNode {
    type: "BlockStatement";
    body: Array<Statement>;
    directives: Array<Directive>;
}


interface BreakStatement extends BaseNode {
    type: "BreakStatement";
    label?: Identifier | null;
}


interface CallExpression extends BaseNode {
    type: "CallExpression";
    callee: Expression | V8IntrinsicIdentifier;
    arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
    optional?: true | false | null;
    typeArguments?: TypeParameterInstantiation | null;
    typeParameters?: TSTypeParameterInstantiation | null;
}


interface CatchClause extends BaseNode {
    type: "CatchClause";
    param?: Identifier | ArrayPattern | ObjectPattern | null;
    body: BlockStatement;
}


interface ConditionalExpression extends BaseNode {
    type: "ConditionalExpression";
    test: Expression;
    consequent: Expression;
    alternate: Expression;
}


interface ContinueStatement extends BaseNode {
    type: "ContinueStatement";
    label?: Identifier | null;
}


interface DebuggerStatement extends BaseNode {
    type: "DebuggerStatement";
}


interface DoWhileStatement extends BaseNode {
    type: "DoWhileStatement";
    test: Expression;
    body: Statement;
}


interface EmptyStatement extends BaseNode {
    type: "EmptyStatement";
}


interface ExpressionStatement extends BaseNode {
    type: "ExpressionStatement";
    expression: Expression;
}


interface File extends BaseNode {
    type: "File";
    program: Program;
    comments?: Array<CommentBlock | CommentLine> | null;
    tokens?: Array<any> | null;
}


interface ForInStatement extends BaseNode {
    type: "ForInStatement";
    left: VariableDeclaration | LVal;
    right: Expression;
    body: Statement;
}


interface ForStatement extends BaseNode {
    type: "ForStatement";
    init?: VariableDeclaration | Expression | null;
    test?: Expression | null;
    update?: Expression | null;
    body: Statement;
}


interface FunctionDeclaration extends BaseNode {
    type: "FunctionDeclaration";
    id?: Identifier | null;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
    generator?: boolean;
    async?: boolean;
    declare?: boolean | null;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface FunctionExpression extends BaseNode {
    type: "FunctionExpression";
    id?: Identifier | null;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
    generator?: boolean;
    async?: boolean;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface Identifier extends BaseNode {
    type: "Identifier";
    name: string;
    decorators?: Array<Decorator> | null;
    optional?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


interface IfStatement extends BaseNode {
    type: "IfStatement";
    test: Expression;
    consequent: Statement;
    alternate?: Statement | null;
}


interface LabeledStatement extends BaseNode {
    type: "LabeledStatement";
    label: Identifier;
    body: Statement;
}


interface StringLiteral extends BaseNode {
    type: "StringLiteral";
    value: string;
}


interface NumericLiteral extends BaseNode {
    type: "NumericLiteral";
    value: number;
}


/**
 * @deprecated Use `NumericLiteral`
 */
interface NumberLiteral$1 extends BaseNode {
    type: "NumberLiteral";
    value: number;
}


interface NullLiteral extends BaseNode {
    type: "NullLiteral";
}


interface BooleanLiteral extends BaseNode {
    type: "BooleanLiteral";
    value: boolean;
}


interface RegExpLiteral extends BaseNode {
    type: "RegExpLiteral";
    pattern: string;
    flags: string;
}


/**
 * @deprecated Use `RegExpLiteral`
 */
interface RegexLiteral$1 extends BaseNode {
    type: "RegexLiteral";
    pattern: string;
    flags: string;
}


interface LogicalExpression extends BaseNode {
    type: "LogicalExpression";
    operator: "||" | "&&" | "??";
    left: Expression;
    right: Expression;
}


interface MemberExpression extends BaseNode {
    type: "MemberExpression";
    object: Expression;
    property: Expression | Identifier | PrivateName;
    computed: boolean;
    optional?: true | false | null;
}


interface NewExpression extends BaseNode {
    type: "NewExpression";
    callee: Expression | V8IntrinsicIdentifier;
    arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
    optional?: true | false | null;
    typeArguments?: TypeParameterInstantiation | null;
    typeParameters?: TSTypeParameterInstantiation | null;
}


interface Program extends BaseNode {
    type: "Program";
    body: Array<Statement>;
    directives: Array<Directive>;
    sourceType: "script" | "module";
    interpreter?: InterpreterDirective | null;
    sourceFile: string;
}


interface ObjectExpression extends BaseNode {
    type: "ObjectExpression";
    properties: Array<ObjectMethod | ObjectProperty | SpreadElement>;
}


interface ObjectMethod extends BaseNode {
    type: "ObjectMethod";
    kind: "method" | "get" | "set";
    key: Expression | Identifier | StringLiteral | NumericLiteral;
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement;
    computed: boolean;
    generator?: boolean;
    async?: boolean;
    decorators?: Array<Decorator> | null;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface ObjectProperty extends BaseNode {
    type: "ObjectProperty";
    key: Expression | Identifier | StringLiteral | NumericLiteral;
    value: Expression | PatternLike;
    computed: boolean;
    shorthand: boolean;
    decorators?: Array<Decorator> | null;
}


interface RestElement extends BaseNode {
    type: "RestElement";
    argument: LVal;
    decorators?: Array<Decorator> | null;
    optional?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


/**
 * @deprecated Use `RestElement`
 */
interface RestProperty$1 extends BaseNode {
    type: "RestProperty";
    argument: LVal;
    decorators?: Array<Decorator> | null;
    optional?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


interface ReturnStatement extends BaseNode {
    type: "ReturnStatement";
    argument?: Expression | null;
}


interface SequenceExpression extends BaseNode {
    type: "SequenceExpression";
    expressions: Array<Expression>;
}


interface ParenthesizedExpression extends BaseNode {
    type: "ParenthesizedExpression";
    expression: Expression;
}


interface SwitchCase extends BaseNode {
    type: "SwitchCase";
    test?: Expression | null;
    consequent: Array<Statement>;
}


interface SwitchStatement extends BaseNode {
    type: "SwitchStatement";
    discriminant: Expression;
    cases: Array<SwitchCase>;
}


interface ThisExpression extends BaseNode {
    type: "ThisExpression";
}


interface ThrowStatement extends BaseNode {
    type: "ThrowStatement";
    argument: Expression;
}


interface TryStatement extends BaseNode {
    type: "TryStatement";
    block: BlockStatement;
    handler?: CatchClause | null;
    finalizer?: BlockStatement | null;
}


interface UnaryExpression extends BaseNode {
    type: "UnaryExpression";
    operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof";
    argument: Expression;
    prefix: boolean;
}


interface UpdateExpression extends BaseNode {
    type: "UpdateExpression";
    operator: "++" | "--";
    argument: Expression;
    prefix: boolean;
}


interface VariableDeclaration extends BaseNode {
    type: "VariableDeclaration";
    kind: "var" | "let" | "const";
    declarations: Array<VariableDeclarator>;
    declare?: boolean | null;
}


interface VariableDeclarator extends BaseNode {
    type: "VariableDeclarator";
    id: LVal;
    init?: Expression | null;
    definite?: boolean | null;
}


interface WhileStatement extends BaseNode {
    type: "WhileStatement";
    test: Expression;
    body: Statement;
}


interface WithStatement extends BaseNode {
    type: "WithStatement";
    object: Expression;
    body: Statement;
}


interface AssignmentPattern extends BaseNode {
    type: "AssignmentPattern";
    left: Identifier | ObjectPattern | ArrayPattern | MemberExpression;
    right: Expression;
    decorators?: Array<Decorator> | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


interface ArrayPattern extends BaseNode {
    type: "ArrayPattern";
    elements: Array<null | PatternLike>;
    decorators?: Array<Decorator> | null;
    optional?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


interface ArrowFunctionExpression extends BaseNode {
    type: "ArrowFunctionExpression";
    params: Array<Identifier | Pattern | RestElement>;
    body: BlockStatement | Expression;
    async?: boolean;
    expression: boolean;
    generator?: boolean;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface ClassBody extends BaseNode {
    type: "ClassBody";
    body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock>;
}


interface ClassExpression extends BaseNode {
    type: "ClassExpression";
    id?: Identifier | null;
    superClass?: Expression | null;
    body: ClassBody;
    decorators?: Array<Decorator> | null;
    implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
    mixins?: InterfaceExtends | null;
    superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface ClassDeclaration extends BaseNode {
    type: "ClassDeclaration";
    id: Identifier;
    superClass?: Expression | null;
    body: ClassBody;
    decorators?: Array<Decorator> | null;
    abstract?: boolean | null;
    declare?: boolean | null;
    implements?: Array<TSExpressionWithTypeArguments | ClassImplements> | null;
    mixins?: InterfaceExtends | null;
    superTypeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface ExportAllDeclaration extends BaseNode {
    type: "ExportAllDeclaration";
    source: StringLiteral;
    assertions?: Array<ImportAttribute> | null;
    exportKind?: "type" | "value" | null;
}


interface ExportDefaultDeclaration extends BaseNode {
    type: "ExportDefaultDeclaration";
    declaration: FunctionDeclaration | TSDeclareFunction | ClassDeclaration | Expression;
    exportKind?: "value" | null;
}


interface ExportNamedDeclaration extends BaseNode {
    type: "ExportNamedDeclaration";
    declaration?: Declaration | null;
    specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier>;
    source?: StringLiteral | null;
    assertions?: Array<ImportAttribute> | null;
    exportKind?: "type" | "value" | null;
}


interface ExportSpecifier extends BaseNode {
    type: "ExportSpecifier";
    local: Identifier;
    exported: Identifier | StringLiteral;
    exportKind?: "type" | "value" | null;
}


interface ForOfStatement extends BaseNode {
    type: "ForOfStatement";
    left: VariableDeclaration | LVal;
    right: Expression;
    body: Statement;
    await: boolean;
}


interface ImportDeclaration extends BaseNode {
    type: "ImportDeclaration";
    specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
    source: StringLiteral;
    assertions?: Array<ImportAttribute> | null;
    importKind?: "type" | "typeof" | "value" | null;
}


interface ImportDefaultSpecifier extends BaseNode {
    type: "ImportDefaultSpecifier";
    local: Identifier;
}


interface ImportNamespaceSpecifier extends BaseNode {
    type: "ImportNamespaceSpecifier";
    local: Identifier;
}


interface ImportSpecifier extends BaseNode {
    type: "ImportSpecifier";
    local: Identifier;
    imported: Identifier | StringLiteral;
    importKind?: "type" | "typeof" | "value" | null;
}


interface MetaProperty extends BaseNode {
    type: "MetaProperty";
    meta: Identifier;
    property: Identifier;
}


interface ClassMethod extends BaseNode {
    type: "ClassMethod";
    kind?: "get" | "set" | "method" | "constructor";
    key: Identifier | StringLiteral | NumericLiteral | Expression;
    params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
    body: BlockStatement;
    computed?: boolean;
    static?: boolean;
    generator?: boolean;
    async?: boolean;
    abstract?: boolean | null;
    access?: "public" | "private" | "protected" | null;
    accessibility?: "public" | "private" | "protected" | null;
    decorators?: Array<Decorator> | null;
    optional?: boolean | null;
    override?: boolean;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface ObjectPattern extends BaseNode {
    type: "ObjectPattern";
    properties: Array<RestElement | ObjectProperty>;
    decorators?: Array<Decorator> | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
}


interface SpreadElement extends BaseNode {
    type: "SpreadElement";
    argument: Expression;
}


/**
 * @deprecated Use `SpreadElement`
 */
interface SpreadProperty$1 extends BaseNode {
    type: "SpreadProperty";
    argument: Expression;
}


interface Super extends BaseNode {
    type: "Super";
}


interface TaggedTemplateExpression extends BaseNode {
    type: "TaggedTemplateExpression";
    tag: Expression;
    quasi: TemplateLiteral;
    typeParameters?: TypeParameterInstantiation | TSTypeParameterInstantiation | null;
}


interface TemplateElement extends BaseNode {
    type: "TemplateElement";
    value: {
        raw: string;
        cooked?: string;
    };
    tail: boolean;
}


interface TemplateLiteral extends BaseNode {
    type: "TemplateLiteral";
    quasis: Array<TemplateElement>;
    expressions: Array<Expression | TSType>;
}


interface YieldExpression extends BaseNode {
    type: "YieldExpression";
    argument?: Expression | null;
    delegate: boolean;
}


interface AwaitExpression extends BaseNode {
    type: "AwaitExpression";
    argument: Expression;
}


interface Import extends BaseNode {
    type: "Import";
}


interface BigIntLiteral extends BaseNode {
    type: "BigIntLiteral";
    value: string;
}


interface ExportNamespaceSpecifier extends BaseNode {
    type: "ExportNamespaceSpecifier";
    exported: Identifier;
}


interface OptionalMemberExpression extends BaseNode {
    type: "OptionalMemberExpression";
    object: Expression;
    property: Expression | Identifier;
    computed: boolean;
    optional: boolean;
}


interface OptionalCallExpression extends BaseNode {
    type: "OptionalCallExpression";
    callee: Expression;
    arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder>;
    optional: boolean;
    typeArguments?: TypeParameterInstantiation | null;
    typeParameters?: TSTypeParameterInstantiation | null;
}


interface ClassProperty extends BaseNode {
    type: "ClassProperty";
    key: Identifier | StringLiteral | NumericLiteral | Expression;
    value?: Expression | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    decorators?: Array<Decorator> | null;
    computed?: boolean;
    static?: boolean;
    abstract?: boolean | null;
    accessibility?: "public" | "private" | "protected" | null;
    declare?: boolean | null;
    definite?: boolean | null;
    optional?: boolean | null;
    override?: boolean;
    readonly?: boolean | null;
    variance?: Variance | null;
}


interface ClassAccessorProperty extends BaseNode {
    type: "ClassAccessorProperty";
    key: Identifier | StringLiteral | NumericLiteral | Expression | PrivateName;
    value?: Expression | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    decorators?: Array<Decorator> | null;
    computed?: boolean;
    static?: boolean;
    abstract?: boolean | null;
    accessibility?: "public" | "private" | "protected" | null;
    declare?: boolean | null;
    definite?: boolean | null;
    optional?: boolean | null;
    override?: boolean;
    readonly?: boolean | null;
    variance?: Variance | null;
}


interface ClassPrivateProperty extends BaseNode {
    type: "ClassPrivateProperty";
    key: PrivateName;
    value?: Expression | null;
    decorators?: Array<Decorator> | null;
    static: any;
    definite?: boolean | null;
    readonly?: boolean | null;
    typeAnnotation?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    variance?: Variance | null;
}


interface ClassPrivateMethod extends BaseNode {
    type: "ClassPrivateMethod";
    kind?: "get" | "set" | "method" | "constructor";
    key: PrivateName;
    params: Array<Identifier | Pattern | RestElement | TSParameterProperty>;
    body: BlockStatement;
    static?: boolean;
    abstract?: boolean | null;
    access?: "public" | "private" | "protected" | null;
    accessibility?: "public" | "private" | "protected" | null;
    async?: boolean;
    computed?: boolean;
    decorators?: Array<Decorator> | null;
    generator?: boolean;
    optional?: boolean | null;
    override?: boolean;
    returnType?: TypeAnnotation | TSTypeAnnotation | Noop | null;
    typeParameters?: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop | null;
}


interface PrivateName extends BaseNode {
    type: "PrivateName";
    id: Identifier;
}


interface StaticBlock extends BaseNode {
    type: "StaticBlock";
    body: Array<Statement>;
}


interface AnyTypeAnnotation extends BaseNode {
    type: "AnyTypeAnnotation";
}


interface ArrayTypeAnnotation extends BaseNode {
    type: "ArrayTypeAnnotation";
    elementType: FlowType;
}


interface BooleanTypeAnnotation extends BaseNode {
    type: "BooleanTypeAnnotation";
}


interface BooleanLiteralTypeAnnotation extends BaseNode {
    type: "BooleanLiteralTypeAnnotation";
    value: boolean;
}


interface NullLiteralTypeAnnotation extends BaseNode {
    type: "NullLiteralTypeAnnotation";
}


interface ClassImplements extends BaseNode {
    type: "ClassImplements";
    id: Identifier;
    typeParameters?: TypeParameterInstantiation | null;
}


interface DeclareClass extends BaseNode {
    type: "DeclareClass";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    extends?: Array<InterfaceExtends> | null;
    body: ObjectTypeAnnotation;
    implements?: Array<ClassImplements> | null;
    mixins?: Array<InterfaceExtends> | null;
}


interface DeclareFunction extends BaseNode {
    type: "DeclareFunction";
    id: Identifier;
    predicate?: DeclaredPredicate | null;
}


interface DeclareInterface extends BaseNode {
    type: "DeclareInterface";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    extends?: Array<InterfaceExtends> | null;
    body: ObjectTypeAnnotation;
    implements?: Array<ClassImplements> | null;
    mixins?: Array<InterfaceExtends> | null;
}


interface DeclareModule extends BaseNode {
    type: "DeclareModule";
    id: Identifier | StringLiteral;
    body: BlockStatement;
    kind?: "CommonJS" | "ES" | null;
}


interface DeclareModuleExports extends BaseNode {
    type: "DeclareModuleExports";
    typeAnnotation: TypeAnnotation;
}


interface DeclareTypeAlias extends BaseNode {
    type: "DeclareTypeAlias";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    right: FlowType;
}


interface DeclareOpaqueType extends BaseNode {
    type: "DeclareOpaqueType";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    supertype?: FlowType | null;
    impltype?: FlowType | null;
}


interface DeclareVariable extends BaseNode {
    type: "DeclareVariable";
    id: Identifier;
}


interface DeclareExportDeclaration extends BaseNode {
    type: "DeclareExportDeclaration";
    declaration?: Flow | null;
    specifiers?: Array<ExportSpecifier | ExportNamespaceSpecifier> | null;
    source?: StringLiteral | null;
    default?: boolean | null;
}


interface DeclareExportAllDeclaration extends BaseNode {
    type: "DeclareExportAllDeclaration";
    source: StringLiteral;
    exportKind?: "type" | "value" | null;
}


interface DeclaredPredicate extends BaseNode {
    type: "DeclaredPredicate";
    value: Flow;
}


interface ExistsTypeAnnotation extends BaseNode {
    type: "ExistsTypeAnnotation";
}


interface FunctionTypeAnnotation extends BaseNode {
    type: "FunctionTypeAnnotation";
    typeParameters?: TypeParameterDeclaration | null;
    params: Array<FunctionTypeParam>;
    rest?: FunctionTypeParam | null;
    returnType: FlowType;
    this?: FunctionTypeParam | null;
}


interface FunctionTypeParam extends BaseNode {
    type: "FunctionTypeParam";
    name?: Identifier | null;
    typeAnnotation: FlowType;
    optional?: boolean | null;
}


interface GenericTypeAnnotation extends BaseNode {
    type: "GenericTypeAnnotation";
    id: Identifier | QualifiedTypeIdentifier;
    typeParameters?: TypeParameterInstantiation | null;
}


interface InferredPredicate extends BaseNode {
    type: "InferredPredicate";
}


interface InterfaceExtends extends BaseNode {
    type: "InterfaceExtends";
    id: Identifier | QualifiedTypeIdentifier;
    typeParameters?: TypeParameterInstantiation | null;
}


interface InterfaceDeclaration extends BaseNode {
    type: "InterfaceDeclaration";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    extends?: Array<InterfaceExtends> | null;
    body: ObjectTypeAnnotation;
    implements?: Array<ClassImplements> | null;
    mixins?: Array<InterfaceExtends> | null;
}


interface InterfaceTypeAnnotation extends BaseNode {
    type: "InterfaceTypeAnnotation";
    extends?: Array<InterfaceExtends> | null;
    body: ObjectTypeAnnotation;
}


interface IntersectionTypeAnnotation extends BaseNode {
    type: "IntersectionTypeAnnotation";
    types: Array<FlowType>;
}


interface MixedTypeAnnotation extends BaseNode {
    type: "MixedTypeAnnotation";
}


interface EmptyTypeAnnotation extends BaseNode {
    type: "EmptyTypeAnnotation";
}


interface NullableTypeAnnotation extends BaseNode {
    type: "NullableTypeAnnotation";
    typeAnnotation: FlowType;
}


interface NumberLiteralTypeAnnotation extends BaseNode {
    type: "NumberLiteralTypeAnnotation";
    value: number;
}


interface NumberTypeAnnotation extends BaseNode {
    type: "NumberTypeAnnotation";
}


interface ObjectTypeAnnotation extends BaseNode {
    type: "ObjectTypeAnnotation";
    properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty>;
    indexers?: Array<ObjectTypeIndexer> | null;
    callProperties?: Array<ObjectTypeCallProperty> | null;
    internalSlots?: Array<ObjectTypeInternalSlot> | null;
    exact: boolean;
    inexact?: boolean | null;
}


interface ObjectTypeInternalSlot extends BaseNode {
    type: "ObjectTypeInternalSlot";
    id: Identifier;
    value: FlowType;
    optional: boolean;
    static: boolean;
    method: boolean;
}


interface ObjectTypeCallProperty extends BaseNode {
    type: "ObjectTypeCallProperty";
    value: FlowType;
    static: boolean;
}


interface ObjectTypeIndexer extends BaseNode {
    type: "ObjectTypeIndexer";
    id?: Identifier | null;
    key: FlowType;
    value: FlowType;
    variance?: Variance | null;
    static: boolean;
}


interface ObjectTypeProperty extends BaseNode {
    type: "ObjectTypeProperty";
    key: Identifier | StringLiteral;
    value: FlowType;
    variance?: Variance | null;
    kind: "init" | "get" | "set";
    method: boolean;
    optional: boolean;
    proto: boolean;
    static: boolean;
}


interface ObjectTypeSpreadProperty extends BaseNode {
    type: "ObjectTypeSpreadProperty";
    argument: FlowType;
}


interface OpaqueType extends BaseNode {
    type: "OpaqueType";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    supertype?: FlowType | null;
    impltype: FlowType;
}


interface QualifiedTypeIdentifier extends BaseNode {
    type: "QualifiedTypeIdentifier";
    id: Identifier;
    qualification: Identifier | QualifiedTypeIdentifier;
}


interface StringLiteralTypeAnnotation extends BaseNode {
    type: "StringLiteralTypeAnnotation";
    value: string;
}


interface StringTypeAnnotation extends BaseNode {
    type: "StringTypeAnnotation";
}


interface SymbolTypeAnnotation extends BaseNode {
    type: "SymbolTypeAnnotation";
}


interface ThisTypeAnnotation extends BaseNode {
    type: "ThisTypeAnnotation";
}


interface TupleTypeAnnotation extends BaseNode {
    type: "TupleTypeAnnotation";
    types: Array<FlowType>;
}


interface TypeofTypeAnnotation extends BaseNode {
    type: "TypeofTypeAnnotation";
    argument: FlowType;
}


interface TypeAlias extends BaseNode {
    type: "TypeAlias";
    id: Identifier;
    typeParameters?: TypeParameterDeclaration | null;
    right: FlowType;
}


interface TypeAnnotation extends BaseNode {
    type: "TypeAnnotation";
    typeAnnotation: FlowType;
}


interface TypeCastExpression extends BaseNode {
    type: "TypeCastExpression";
    expression: Expression;
    typeAnnotation: TypeAnnotation;
}