Skip to main content

@babel/types

This module contains methods for building ASTs manually and for checking the types of AST nodes.

Install

npm install --save-dev @babel/types

API

Node Builders

anyTypeAnnotation

JavaScript
t.anyTypeAnnotation();

See also t.isAnyTypeAnnotation(node, opts) and t.assertAnyTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


argumentPlaceholder

JavaScript
t.argumentPlaceholder();

See also t.isArgumentPlaceholder(node, opts) and t.assertArgumentPlaceholder(node, opts).


arrayExpression

JavaScript
t.arrayExpression(elements);

See also t.isArrayExpression(node, opts) and t.assertArrayExpression(node, opts).

AST Node ArrayExpression shape:

  • elements: Array<null | Expression | SpreadElement> (default: [])

Aliases: Standardized, Expression


arrayPattern

JavaScript
t.arrayPattern(elements);

See also t.isArrayPattern(node, opts) and t.assertArrayPattern(node, opts).

AST Node ArrayPattern shape:

  • elements: Array<null | PatternLike | LVal> (required)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)

Aliases: Standardized, Pattern, PatternLike, LVal


arrayTypeAnnotation

JavaScript
t.arrayTypeAnnotation(elementType);

See also t.isArrayTypeAnnotation(node, opts) and t.assertArrayTypeAnnotation(node, opts).

AST Node ArrayTypeAnnotation shape:

  • elementType: FlowType (required)

Aliases: Flow, FlowType


arrowFunctionExpression

JavaScript
t.arrowFunctionExpression(params, body, async);

See also t.isArrowFunctionExpression(node, opts) and t.assertArrowFunctionExpression(node, opts).

AST Node ArrowFunctionExpression shape:

  • params: Array<Identifier | Pattern | RestElement> (required)
  • body: BlockStatement | Expression (required)
  • async: boolean (default: false)
  • expression: boolean (required)
  • generator: boolean (default: false, excluded from builder function)
  • predicate: DeclaredPredicate | InferredPredicate (default: null, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Expression, Pureish


assignmentExpression

JavaScript
t.assignmentExpression(operator, left, right);

See also t.isAssignmentExpression(node, opts) and t.assertAssignmentExpression(node, opts).

AST Node AssignmentExpression shape:

  • operator: string (required)
  • left: LVal | OptionalMemberExpression (required)
  • right: Expression (required)

Aliases: Standardized, Expression


assignmentPattern

JavaScript
t.assignmentPattern(left, right);

See also t.isAssignmentPattern(node, opts) and t.assertAssignmentPattern(node, opts).

AST Node AssignmentPattern shape:

  • left: Identifier | ObjectPattern | ArrayPattern | MemberExpression | TSAsExpression | TSSatisfiesExpression | TSTypeAssertion | TSNonNullExpression (required)
  • right: Expression (required)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)

Aliases: Standardized, Pattern, PatternLike, LVal


awaitExpression

JavaScript
t.awaitExpression(argument);

See also t.isAwaitExpression(node, opts) and t.assertAwaitExpression(node, opts).

AST Node AwaitExpression shape:

  • argument: Expression (required)

Aliases: Standardized, Expression, Terminatorless


bigIntLiteral

JavaScript
t.bigIntLiteral(value);

See also t.isBigIntLiteral(node, opts) and t.assertBigIntLiteral(node, opts).

AST Node BigIntLiteral shape:

  • value: string (required)

Aliases: Standardized, Expression, Pureish, Literal, Immutable


binaryExpression

JavaScript
t.binaryExpression(operator, left, right);

See also t.isBinaryExpression(node, opts) and t.assertBinaryExpression(node, opts).

AST Node BinaryExpression shape:

  • operator: "+" | "-" | "/" | "%" | "*" | "**" | "&" | "|" | ">>" | ">>>" | "<<" | "^" | "==" | "===" | "!=" | "!==" | "in" | "instanceof" | ">" | "<" | ">=" | "<=" | "|>" (required)
  • left: Expression | PrivateName (required)
  • right: Expression (required)

Aliases: Standardized, Binary, Expression


bindExpression

JavaScript
t.bindExpression(object, callee);

See also t.isBindExpression(node, opts) and t.assertBindExpression(node, opts).

AST Node BindExpression shape:

  • object: Expression (required)
  • callee: Expression (required)

Aliases: Expression


blockStatement

JavaScript
t.blockStatement(body, directives);

See also t.isBlockStatement(node, opts) and t.assertBlockStatement(node, opts).

AST Node BlockStatement shape:

  • body: Array<Statement> (required)
  • directives: Array<Directive> (default: [])

Aliases: Standardized, Scopable, BlockParent, Block, Statement


booleanLiteral

JavaScript
t.booleanLiteral(value);

See also t.isBooleanLiteral(node, opts) and t.assertBooleanLiteral(node, opts).

AST Node BooleanLiteral shape:

  • value: boolean (required)

Aliases: Standardized, Expression, Pureish, Literal, Immutable


booleanLiteralTypeAnnotation

JavaScript
t.booleanLiteralTypeAnnotation(value);

See also t.isBooleanLiteralTypeAnnotation(node, opts) and t.assertBooleanLiteralTypeAnnotation(node, opts).

AST Node BooleanLiteralTypeAnnotation shape:

  • value: boolean (required)

Aliases: Flow, FlowType


booleanTypeAnnotation

JavaScript
t.booleanTypeAnnotation();

See also t.isBooleanTypeAnnotation(node, opts) and t.assertBooleanTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


breakStatement

JavaScript
t.breakStatement(label);

See also t.isBreakStatement(node, opts) and t.assertBreakStatement(node, opts).

AST Node BreakStatement shape:

  • label: Identifier (default: null)

Aliases: Standardized, Statement, Terminatorless, CompletionStatement


callExpression

JavaScript
t.callExpression(callee, arguments);

See also t.isCallExpression(node, opts) and t.assertCallExpression(node, opts).

AST Node CallExpression shape:

  • callee: Expression | Super | V8IntrinsicIdentifier (required)
  • arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder> (required)
  • optional: true | false (default: null, excluded from builder function)
  • typeArguments: TypeParameterInstantiation (default: null, excluded from builder function)
  • typeParameters: TSTypeParameterInstantiation (default: null, excluded from builder function)

Aliases: Standardized, Expression


catchClause

JavaScript
t.catchClause(param, body);

See also t.isCatchClause(node, opts) and t.assertCatchClause(node, opts).

AST Node CatchClause shape:

  • param: Identifier | ArrayPattern | ObjectPattern (default: null)
  • body: BlockStatement (required)

Aliases: Standardized, Scopable, BlockParent


classAccessorProperty

JavaScript
t.classAccessorProperty(key, value, typeAnnotation, decorators, computed, static);

See also t.isClassAccessorProperty(node, opts) and t.assertClassAccessorProperty(node, opts).

AST Node ClassAccessorProperty shape:

  • key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression | PrivateName (required)
  • value: Expression (default: null)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null)
  • decorators: Array<Decorator> (default: null)
  • computed: boolean (default: false)
  • static: boolean (default: false)
  • abstract: boolean (default: null, excluded from builder function)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • declare: boolean (default: null, excluded from builder function)
  • definite: boolean (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • override: boolean (default: false, excluded from builder function)
  • readonly: boolean (default: null, excluded from builder function)
  • variance: Variance (default: null, excluded from builder function)

Aliases: Standardized, Property, Accessor


classBody

JavaScript
t.classBody(body);

See also t.isClassBody(node, opts) and t.assertClassBody(node, opts).

AST Node ClassBody shape:

  • body: Array<ClassMethod | ClassPrivateMethod | ClassProperty | ClassPrivateProperty | ClassAccessorProperty | TSDeclareMethod | TSIndexSignature | StaticBlock> (required)

Aliases: Standardized


classDeclaration

JavaScript
t.classDeclaration(id, superClass, body, decorators);

See also t.isClassDeclaration(node, opts) and t.assertClassDeclaration(node, opts).

AST Node ClassDeclaration shape:

  • id: Identifier (default: null)
  • superClass: Expression (default: null)
  • body: ClassBody (required)
  • decorators: Array<Decorator> (default: null)
  • abstract: boolean (default: null, excluded from builder function)
  • declare: boolean (default: null, excluded from builder function)
  • implements: Array<TSExpressionWithTypeArguments | ClassImplements> (default: null, excluded from builder function)
  • mixins: InterfaceExtends (default: null, excluded from builder function)
  • superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Scopable, Class, Statement, Declaration


classExpression

JavaScript
t.classExpression(id, superClass, body, decorators);

See also t.isClassExpression(node, opts) and t.assertClassExpression(node, opts).

AST Node ClassExpression shape:

  • id: Identifier (default: null)
  • superClass: Expression (default: null)
  • body: ClassBody (required)
  • decorators: Array<Decorator> (default: null)
  • implements: Array<TSExpressionWithTypeArguments | ClassImplements> (default: null, excluded from builder function)
  • mixins: InterfaceExtends (default: null, excluded from builder function)
  • superTypeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Scopable, Class, Expression


classImplements

JavaScript
t.classImplements(id, typeParameters);

See also t.isClassImplements(node, opts) and t.assertClassImplements(node, opts).

AST Node ClassImplements shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterInstantiation (default: null)

Aliases: Flow


classMethod

JavaScript
t.classMethod(kind, key, params, body, computed, static, generator, async);

See also t.isClassMethod(node, opts) and t.assertClassMethod(node, opts).

AST Node ClassMethod shape:

  • kind: "get" | "set" | "method" | "constructor" (default: 'method')
  • key: if computed then Expression else Identifier | Literal (required)
  • params: Array<Identifier | Pattern | RestElement | TSParameterProperty> (required)
  • body: BlockStatement (required)
  • computed: boolean (default: false)
  • static: boolean (default: false)
  • generator: boolean (default: false)
  • async: boolean (default: false)
  • abstract: boolean (default: null, excluded from builder function)
  • access: "public" | "private" | "protected" (default: null, excluded from builder function)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • override: boolean (default: false, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Function, Scopable, BlockParent, FunctionParent, Method


classPrivateMethod

JavaScript
t.classPrivateMethod(kind, key, params, body, static);

See also t.isClassPrivateMethod(node, opts) and t.assertClassPrivateMethod(node, opts).

AST Node ClassPrivateMethod shape:

  • kind: "get" | "set" | "method" (default: 'method')
  • key: PrivateName (required)
  • params: Array<Identifier | Pattern | RestElement | TSParameterProperty> (required)
  • body: BlockStatement (required)
  • static: boolean (default: false)
  • abstract: boolean (default: null, excluded from builder function)
  • access: "public" | "private" | "protected" (default: null, excluded from builder function)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • async: boolean (default: false, excluded from builder function)
  • computed: 'false' (default: false, excluded from builder function)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • generator: boolean (default: false, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • override: boolean (default: false, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Function, Scopable, BlockParent, FunctionParent, Method, Private


classPrivateProperty

JavaScript
t.classPrivateProperty(key, value, decorators, static);

See also t.isClassPrivateProperty(node, opts) and t.assertClassPrivateProperty(node, opts).

AST Node ClassPrivateProperty shape:

  • key: PrivateName (required)
  • value: Expression (default: null)
  • decorators: Array<Decorator> (default: null)
  • static: boolean (default: false)
  • definite: boolean (default: null, excluded from builder function)
  • readonly: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • variance: Variance (default: null, excluded from builder function)

Aliases: Standardized, Property, Private


classProperty

JavaScript
t.classProperty(key, value, typeAnnotation, decorators, computed, static);
History
VersionChanges
v7.6.0Supports static

See also t.isClassProperty(node, opts) and t.assertClassProperty(node, opts).

AST Node ClassProperty shape:

  • key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression (required)
  • value: Expression (default: null)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null)
  • decorators: Array<Decorator> (default: null)
  • computed: boolean (default: false)
  • static: boolean (default: false)
  • abstract: boolean (default: null, excluded from builder function)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • declare: boolean (default: null, excluded from builder function)
  • definite: boolean (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • override: boolean (default: false, excluded from builder function)
  • readonly: boolean (default: null, excluded from builder function)
  • variance: Variance (default: null, excluded from builder function)

Aliases: Standardized, Property


conditionalExpression

JavaScript
t.conditionalExpression(test, consequent, alternate);

See also t.isConditionalExpression(node, opts) and t.assertConditionalExpression(node, opts).

AST Node ConditionalExpression shape:

  • test: Expression (required)
  • consequent: Expression (required)
  • alternate: Expression (required)

Aliases: Standardized, Expression, Conditional


continueStatement

JavaScript
t.continueStatement(label);

See also t.isContinueStatement(node, opts) and t.assertContinueStatement(node, opts).

AST Node ContinueStatement shape:

  • label: Identifier (default: null)

Aliases: Standardized, Statement, Terminatorless, CompletionStatement


debuggerStatement

JavaScript
t.debuggerStatement();

See also t.isDebuggerStatement(node, opts) and t.assertDebuggerStatement(node, opts).

Aliases: Standardized, Statement


decimalLiteral

JavaScript
t.decimalLiteral(value);

See also t.isDecimalLiteral(node, opts) and t.assertDecimalLiteral(node, opts).

AST Node DecimalLiteral shape:

  • value: string (required)

Aliases: Expression, Pureish, Literal, Immutable


declareClass

JavaScript
t.declareClass(id, typeParameters, extends, body);

See also t.isDeclareClass(node, opts) and t.assertDeclareClass(node, opts).

AST Node DeclareClass shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • extends: Array<InterfaceExtends> (default: null)
  • body: ObjectTypeAnnotation (required)
  • implements: Array<ClassImplements> (default: null, excluded from builder function)
  • mixins: Array<InterfaceExtends> (default: null, excluded from builder function)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareExportAllDeclaration

JavaScript
t.declareExportAllDeclaration(source);

See also t.isDeclareExportAllDeclaration(node, opts) and t.assertDeclareExportAllDeclaration(node, opts).

AST Node DeclareExportAllDeclaration shape:

  • source: StringLiteral (required)
  • exportKind: "type" | "value" (default: null, excluded from builder function)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareExportDeclaration

JavaScript
t.declareExportDeclaration(declaration, specifiers, source);

See also t.isDeclareExportDeclaration(node, opts) and t.assertDeclareExportDeclaration(node, opts).

AST Node DeclareExportDeclaration shape:

  • declaration: Flow (default: null)
  • specifiers: Array<ExportSpecifier | ExportNamespaceSpecifier> (default: null)
  • source: StringLiteral (default: null)
  • default: boolean (default: null, excluded from builder function)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareFunction

JavaScript
t.declareFunction(id);

See also t.isDeclareFunction(node, opts) and t.assertDeclareFunction(node, opts).

AST Node DeclareFunction shape:

  • id: Identifier (required)
  • predicate: DeclaredPredicate (default: null, excluded from builder function)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareInterface

JavaScript
t.declareInterface(id, typeParameters, extends, body);

See also t.isDeclareInterface(node, opts) and t.assertDeclareInterface(node, opts).

AST Node DeclareInterface shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • extends: Array<InterfaceExtends> (default: null)
  • body: ObjectTypeAnnotation (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareModule

JavaScript
t.declareModule(id, body, kind);

See also t.isDeclareModule(node, opts) and t.assertDeclareModule(node, opts).

AST Node DeclareModule shape:

  • id: Identifier | StringLiteral (required)
  • body: BlockStatement (required)
  • kind: "CommonJS" | "ES" (default: null)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareModuleExports

JavaScript
t.declareModuleExports(typeAnnotation);

See also t.isDeclareModuleExports(node, opts) and t.assertDeclareModuleExports(node, opts).

AST Node DeclareModuleExports shape:

  • typeAnnotation: TypeAnnotation (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareOpaqueType

JavaScript
t.declareOpaqueType(id, typeParameters, supertype);

See also t.isDeclareOpaqueType(node, opts) and t.assertDeclareOpaqueType(node, opts).

AST Node DeclareOpaqueType shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • supertype: FlowType (default: null)
  • impltype: FlowType (default: null, excluded from builder function)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareTypeAlias

JavaScript
t.declareTypeAlias(id, typeParameters, right);

See also t.isDeclareTypeAlias(node, opts) and t.assertDeclareTypeAlias(node, opts).

AST Node DeclareTypeAlias shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • right: FlowType (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declareVariable

JavaScript
t.declareVariable(id);

See also t.isDeclareVariable(node, opts) and t.assertDeclareVariable(node, opts).

AST Node DeclareVariable shape:

  • id: Identifier (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


declaredPredicate

JavaScript
t.declaredPredicate(value);

See also t.isDeclaredPredicate(node, opts) and t.assertDeclaredPredicate(node, opts).

AST Node DeclaredPredicate shape:

  • value: Flow (required)

Aliases: Flow, FlowPredicate


decorator

JavaScript
t.decorator(expression);

See also t.isDecorator(node, opts) and t.assertDecorator(node, opts).

AST Node Decorator shape:

  • expression: Expression (required)

directive

JavaScript
t.directive(value);

See also t.isDirective(node, opts) and t.assertDirective(node, opts).

AST Node Directive shape:

  • value: DirectiveLiteral (required)

Aliases: Standardized


directiveLiteral

JavaScript
t.directiveLiteral(value);

See also t.isDirectiveLiteral(node, opts) and t.assertDirectiveLiteral(node, opts).

AST Node DirectiveLiteral shape:

  • value: string (required)

Aliases: Standardized


doExpression

JavaScript
t.doExpression(body, async);

See also t.isDoExpression(node, opts) and t.assertDoExpression(node, opts).

AST Node DoExpression shape:

  • body: BlockStatement (required)
  • async: boolean (default: false)

Aliases: Expression


doWhileStatement

JavaScript
t.doWhileStatement(test, body);

See also t.isDoWhileStatement(node, opts) and t.assertDoWhileStatement(node, opts).

AST Node DoWhileStatement shape:

  • test: Expression (required)
  • body: Statement (required)

Aliases: Standardized, Statement, BlockParent, Loop, While, Scopable


emptyStatement

JavaScript
t.emptyStatement();

See also t.isEmptyStatement(node, opts) and t.assertEmptyStatement(node, opts).

Aliases: Standardized, Statement


emptyTypeAnnotation

JavaScript
t.emptyTypeAnnotation();

See also t.isEmptyTypeAnnotation(node, opts) and t.assertEmptyTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


enumBooleanBody

JavaScript
t.enumBooleanBody(members);

See also t.isEnumBooleanBody(node, opts) and t.assertEnumBooleanBody(node, opts).

AST Node EnumBooleanBody shape:

  • members: Array<EnumBooleanMember> (required)
  • explicitType: boolean (required)
  • hasUnknownMembers: boolean (required)

Aliases: Flow, EnumBody


enumBooleanMember

JavaScript
t.enumBooleanMember(id);

See also t.isEnumBooleanMember(node, opts) and t.assertEnumBooleanMember(node, opts).

AST Node EnumBooleanMember shape:

  • id: Identifier (required)
  • init: BooleanLiteral (required)

Aliases: Flow, EnumMember


enumDeclaration

JavaScript
t.enumDeclaration(id, body);

See also t.isEnumDeclaration(node, opts) and t.assertEnumDeclaration(node, opts).

AST Node EnumDeclaration shape:

  • id: Identifier (required)
  • body: EnumBooleanBody | EnumNumberBody | EnumStringBody | EnumSymbolBody (required)

Aliases: Flow, Statement, Declaration


enumDefaultedMember

JavaScript
t.enumDefaultedMember(id);

See also t.isEnumDefaultedMember(node, opts) and t.assertEnumDefaultedMember(node, opts).

AST Node EnumDefaultedMember shape:

  • id: Identifier (required)

Aliases: Flow, EnumMember


enumNumberBody

JavaScript
t.enumNumberBody(members);

See also t.isEnumNumberBody(node, opts) and t.assertEnumNumberBody(node, opts).

AST Node EnumNumberBody shape:

  • members: Array<EnumNumberMember> (required)
  • explicitType: boolean (required)
  • hasUnknownMembers: boolean (required)

Aliases: Flow, EnumBody


enumNumberMember

JavaScript
t.enumNumberMember(id, init);

See also t.isEnumNumberMember(node, opts) and t.assertEnumNumberMember(node, opts).

AST Node EnumNumberMember shape:

  • id: Identifier (required)
  • init: NumericLiteral (required)

Aliases: Flow, EnumMember


enumStringBody

JavaScript
t.enumStringBody(members);

See also t.isEnumStringBody(node, opts) and t.assertEnumStringBody(node, opts).

AST Node EnumStringBody shape:

  • members: Array<EnumStringMember | EnumDefaultedMember> (required)
  • explicitType: boolean (required)
  • hasUnknownMembers: boolean (required)

Aliases: Flow, EnumBody


enumStringMember

JavaScript
t.enumStringMember(id, init);

See also t.isEnumStringMember(node, opts) and t.assertEnumStringMember(node, opts).

AST Node EnumStringMember shape:

  • id: Identifier (required)
  • init: StringLiteral (required)

Aliases: Flow, EnumMember


enumSymbolBody

JavaScript
t.enumSymbolBody(members);

See also t.isEnumSymbolBody(node, opts) and t.assertEnumSymbolBody(node, opts).

AST Node EnumSymbolBody shape:

  • members: Array<EnumDefaultedMember> (required)
  • hasUnknownMembers: boolean (required)

Aliases: Flow, EnumBody


existsTypeAnnotation

JavaScript
t.existsTypeAnnotation();

See also t.isExistsTypeAnnotation(node, opts) and t.assertExistsTypeAnnotation(node, opts).

Aliases: Flow, FlowType


exportAllDeclaration

JavaScript
t.exportAllDeclaration(source);

See also t.isExportAllDeclaration(node, opts) and t.assertExportAllDeclaration(node, opts).

AST Node ExportAllDeclaration shape:

  • source: StringLiteral (required)
  • assertions: Array<ImportAttribute> (default: null, excluded from builder function)
  • attributes: Array<ImportAttribute> (default: null, excluded from builder function)
  • exportKind: "type" | "value" (default: null, excluded from builder function)

Aliases: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration


exportDefaultDeclaration

JavaScript
t.exportDefaultDeclaration(declaration);

See also t.isExportDefaultDeclaration(node, opts) and t.assertExportDefaultDeclaration(node, opts).

AST Node ExportDefaultDeclaration shape:

  • declaration: TSDeclareFunction | FunctionDeclaration | ClassDeclaration | Expression (required)
  • exportKind: "value" (default: null, excluded from builder function)

Aliases: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration


exportDefaultSpecifier

JavaScript
t.exportDefaultSpecifier(exported);

See also t.isExportDefaultSpecifier(node, opts) and t.assertExportDefaultSpecifier(node, opts).

AST Node ExportDefaultSpecifier shape:

  • exported: Identifier (required)

Aliases: ModuleSpecifier


exportNamedDeclaration

JavaScript
t.exportNamedDeclaration(declaration, specifiers, source);

See also t.isExportNamedDeclaration(node, opts) and t.assertExportNamedDeclaration(node, opts).

AST Node ExportNamedDeclaration shape:

  • declaration: Declaration (default: null)
  • specifiers: Array<ExportSpecifier | ExportDefaultSpecifier | ExportNamespaceSpecifier> (default: [])
  • source: StringLiteral (default: null)
  • assertions: Array<ImportAttribute> (default: null, excluded from builder function)
  • attributes: Array<ImportAttribute> (default: null, excluded from builder function)
  • exportKind: "type" | "value" (default: null, excluded from builder function)

Aliases: Standardized, Statement, Declaration, ImportOrExportDeclaration, ExportDeclaration


exportNamespaceSpecifier

JavaScript
t.exportNamespaceSpecifier(exported);

See also t.isExportNamespaceSpecifier(node, opts) and t.assertExportNamespaceSpecifier(node, opts).

AST Node ExportNamespaceSpecifier shape:

  • exported: Identifier (required)

Aliases: Standardized, ModuleSpecifier


exportSpecifier

JavaScript
t.exportSpecifier(local, exported);

See also t.isExportSpecifier(node, opts) and t.assertExportSpecifier(node, opts).

AST Node ExportSpecifier shape:

  • local: Identifier (required)
  • exported: Identifier | StringLiteral (required)
  • exportKind: "type" | "value" (default: null, excluded from builder function)

Aliases: Standardized, ModuleSpecifier


expressionStatement

JavaScript
t.expressionStatement(expression);

See also t.isExpressionStatement(node, opts) and t.assertExpressionStatement(node, opts).

AST Node ExpressionStatement shape:

  • expression: Expression (required)

Aliases: Standardized, Statement, ExpressionWrapper


file

JavaScript
t.file(program, comments, tokens);

See also t.isFile(node, opts) and t.assertFile(node, opts).

AST Node File shape:

  • program: Program (required)
  • comments: Array<CommentBlock | CommentLine> (default: null)
  • tokens: Array<any> (default: null)

Aliases: Standardized


forInStatement

JavaScript
t.forInStatement(left, right, body);

See also t.isForInStatement(node, opts) and t.assertForInStatement(node, opts).

AST Node ForInStatement shape:

  • left: VariableDeclaration | LVal (required)
  • right: Expression (required)
  • body: Statement (required)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop, ForXStatement


forOfStatement

JavaScript
t.forOfStatement(left, right, body, await);

See also t.isForOfStatement(node, opts) and t.assertForOfStatement(node, opts).

AST Node ForOfStatement shape:

  • left: VariableDeclaration | LVal (required)
  • right: Expression (required)
  • body: Statement (required)
  • await: boolean (default: false)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop, ForXStatement


forStatement

JavaScript
t.forStatement(init, test, update, body);

See also t.isForStatement(node, opts) and t.assertForStatement(node, opts).

AST Node ForStatement shape:

  • init: VariableDeclaration | Expression (default: null)
  • test: Expression (default: null)
  • update: Expression (default: null)
  • body: Statement (required)

Aliases: Standardized, Scopable, Statement, For, BlockParent, Loop


functionDeclaration

JavaScript
t.functionDeclaration(id, params, body, generator, async);

See also t.isFunctionDeclaration(node, opts) and t.assertFunctionDeclaration(node, opts).

AST Node FunctionDeclaration shape:

  • id: Identifier (default: null)
  • params: Array<Identifier | Pattern | RestElement> (required)
  • body: BlockStatement (required)
  • generator: boolean (default: false)
  • async: boolean (default: false)
  • declare: boolean (default: null, excluded from builder function)
  • predicate: DeclaredPredicate | InferredPredicate (default: null, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Statement, Pureish, Declaration


functionExpression

JavaScript
t.functionExpression(id, params, body, generator, async);

See also t.isFunctionExpression(node, opts) and t.assertFunctionExpression(node, opts).

AST Node FunctionExpression shape:

  • id: Identifier (default: null)
  • params: Array<Identifier | Pattern | RestElement> (required)
  • body: BlockStatement (required)
  • generator: boolean (default: false)
  • async: boolean (default: false)
  • predicate: DeclaredPredicate | InferredPredicate (default: null, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, Scopable, Function, BlockParent, FunctionParent, Expression, Pureish


functionTypeAnnotation

JavaScript
t.functionTypeAnnotation(typeParameters, params, rest, returnType);

See also t.isFunctionTypeAnnotation(node, opts) and t.assertFunctionTypeAnnotation(node, opts).

AST Node FunctionTypeAnnotation shape:

  • typeParameters: TypeParameterDeclaration (default: null)
  • params: Array<FunctionTypeParam> (required)
  • rest: FunctionTypeParam (default: null)
  • returnType: FlowType (required)
  • this: FunctionTypeParam (default: null, excluded from builder function)

Aliases: Flow, FlowType


functionTypeParam

JavaScript
t.functionTypeParam(name, typeAnnotation);

See also t.isFunctionTypeParam(node, opts) and t.assertFunctionTypeParam(node, opts).

AST Node FunctionTypeParam shape:

  • name: Identifier (default: null)
  • typeAnnotation: FlowType (required)
  • optional: boolean (default: null, excluded from builder function)

Aliases: Flow


genericTypeAnnotation

JavaScript
t.genericTypeAnnotation(id, typeParameters);

See also t.isGenericTypeAnnotation(node, opts) and t.assertGenericTypeAnnotation(node, opts).

AST Node GenericTypeAnnotation shape:

  • id: Identifier | QualifiedTypeIdentifier (required)
  • typeParameters: TypeParameterInstantiation (default: null)

Aliases: Flow, FlowType


identifier

JavaScript
t.identifier(name);

See also t.isIdentifier(node, opts) and t.assertIdentifier(node, opts).

AST Node Identifier shape:

  • name: string (required)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)

Aliases: Standardized, Expression, PatternLike, LVal, TSEntityName


ifStatement

JavaScript
t.ifStatement(test, consequent, alternate);

See also t.isIfStatement(node, opts) and t.assertIfStatement(node, opts).

AST Node IfStatement shape:

  • test: Expression (required)
  • consequent: Statement (required)
  • alternate: Statement (default: null)

Aliases: Standardized, Statement, Conditional


import

JavaScript
t.import();

See also t.isImport(node, opts) and t.assertImport(node, opts).

Aliases: Standardized, Expression


importAttribute

JavaScript
t.importAttribute(key, value);

See also t.isImportAttribute(node, opts) and t.assertImportAttribute(node, opts).

AST Node ImportAttribute shape:

  • key: Identifier | StringLiteral (required)
  • value: StringLiteral (required)

importDeclaration

JavaScript
t.importDeclaration(specifiers, source);
History
VersionChanges
v7.20.0Supports module

See also t.isImportDeclaration(node, opts) and t.assertImportDeclaration(node, opts).

AST Node ImportDeclaration shape:

  • specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier> (required)
  • source: StringLiteral (required)
  • assertions: Array<ImportAttribute> (default: null, excluded from builder function)
  • attributes: Array<ImportAttribute> (default: null, excluded from builder function)
  • importKind: "type" | "typeof" | "value" (default: null, excluded from builder function)
  • module: boolean (default: null, excluded from builder function)
  • phase: "source" | "defer" (default: null, excluded from builder function)

Aliases: Standardized, Statement, Declaration, ImportOrExportDeclaration


importDefaultSpecifier

JavaScript
t.importDefaultSpecifier(local);

See also t.isImportDefaultSpecifier(node, opts) and t.assertImportDefaultSpecifier(node, opts).

AST Node ImportDefaultSpecifier shape:

  • local: Identifier (required)

Aliases: Standardized, ModuleSpecifier


importExpression

JavaScript
t.importExpression(source, options);

See also t.isImportExpression(node, opts) and t.assertImportExpression(node, opts).

AST Node ImportExpression shape:

  • source: Expression (required)
  • options: Expression (default: null)
  • phase: "source" | "defer" (default: null, excluded from builder function)

Aliases: Standardized, Expression


importNamespaceSpecifier

JavaScript
t.importNamespaceSpecifier(local);

See also t.isImportNamespaceSpecifier(node, opts) and t.assertImportNamespaceSpecifier(node, opts).

AST Node ImportNamespaceSpecifier shape:

  • local: Identifier (required)

Aliases: Standardized, ModuleSpecifier


importSpecifier

JavaScript
t.importSpecifier(local, imported);

See also t.isImportSpecifier(node, opts) and t.assertImportSpecifier(node, opts).

AST Node ImportSpecifier shape:

  • local: Identifier (required)
  • imported: Identifier | StringLiteral (required)
  • importKind: "type" | "typeof" | "value" (default: null, excluded from builder function)

Aliases: Standardized, ModuleSpecifier


indexedAccessType

JavaScript
t.indexedAccessType(objectType, indexType);

See also t.isIndexedAccessType(node, opts) and t.assertIndexedAccessType(node, opts).

AST Node IndexedAccessType shape:

  • objectType: FlowType (required)
  • indexType: FlowType (required)

Aliases: Flow, FlowType


inferredPredicate

JavaScript
t.inferredPredicate();

See also t.isInferredPredicate(node, opts) and t.assertInferredPredicate(node, opts).

Aliases: Flow, FlowPredicate


interfaceDeclaration

JavaScript
t.interfaceDeclaration(id, typeParameters, extends, body);

See also t.isInterfaceDeclaration(node, opts) and t.assertInterfaceDeclaration(node, opts).

AST Node InterfaceDeclaration shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • extends: Array<InterfaceExtends> (default: null)
  • body: ObjectTypeAnnotation (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


interfaceExtends

JavaScript
t.interfaceExtends(id, typeParameters);

See also t.isInterfaceExtends(node, opts) and t.assertInterfaceExtends(node, opts).

AST Node InterfaceExtends shape:

  • id: Identifier | QualifiedTypeIdentifier (required)
  • typeParameters: TypeParameterInstantiation (default: null)

Aliases: Flow


interfaceTypeAnnotation

JavaScript
t.interfaceTypeAnnotation(extends, body);

See also t.isInterfaceTypeAnnotation(node, opts) and t.assertInterfaceTypeAnnotation(node, opts).

AST Node InterfaceTypeAnnotation shape:

  • extends: Array<InterfaceExtends> (default: null)
  • body: ObjectTypeAnnotation (required)

Aliases: Flow, FlowType


interpreterDirective

JavaScript
t.interpreterDirective(value);

See also t.isInterpreterDirective(node, opts) and t.assertInterpreterDirective(node, opts).

AST Node InterpreterDirective shape:

  • value: string (required)

Aliases: Standardized


intersectionTypeAnnotation

JavaScript
t.intersectionTypeAnnotation(types);

See also t.isIntersectionTypeAnnotation(node, opts) and t.assertIntersectionTypeAnnotation(node, opts).

AST Node IntersectionTypeAnnotation shape:

  • types: Array<FlowType> (required)

Aliases: Flow, FlowType


jsxAttribute

JavaScript
t.jsxAttribute(name, value);

See also t.isJSXAttribute(node, opts) and t.assertJSXAttribute(node, opts).

AST Node JSXAttribute shape:

  • name: JSXIdentifier | JSXNamespacedName (required)
  • value: JSXElement | JSXFragment | StringLiteral | JSXExpressionContainer (default: null)

Aliases: JSX, Immutable


jsxClosingElement

JavaScript
t.jsxClosingElement(name);

See also t.isJSXClosingElement(node, opts) and t.assertJSXClosingElement(node, opts).

AST Node JSXClosingElement shape:

  • name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName (required)

Aliases: JSX, Immutable


jsxClosingFragment

JavaScript
t.jsxClosingFragment();

See also t.isJSXClosingFragment(node, opts) and t.assertJSXClosingFragment(node, opts).

Aliases: JSX, Immutable


jsxElement

JavaScript
t.jsxElement(openingElement, closingElement, children, selfClosing);

See also t.isJSXElement(node, opts) and t.assertJSXElement(node, opts).

AST Node JSXElement shape:

  • openingElement: JSXOpeningElement (required)
  • closingElement: JSXClosingElement (default: null)
  • children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment> (required)
  • selfClosing: boolean (default: null)

Aliases: JSX, Immutable, Expression


jsxEmptyExpression

JavaScript
t.jsxEmptyExpression();

See also t.isJSXEmptyExpression(node, opts) and t.assertJSXEmptyExpression(node, opts).

Aliases: JSX


jsxExpressionContainer

JavaScript
t.jsxExpressionContainer(expression);

See also t.isJSXExpressionContainer(node, opts) and t.assertJSXExpressionContainer(node, opts).

AST Node JSXExpressionContainer shape:

  • expression: Expression | JSXEmptyExpression (required)

Aliases: JSX, Immutable


jsxFragment

JavaScript
t.jsxFragment(openingFragment, closingFragment, children);

See also t.isJSXFragment(node, opts) and t.assertJSXFragment(node, opts).

AST Node JSXFragment shape:

  • openingFragment: JSXOpeningFragment (required)
  • closingFragment: JSXClosingFragment (required)
  • children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment> (required)

Aliases: JSX, Immutable, Expression


jsxIdentifier

JavaScript
t.jsxIdentifier(name);

See also t.isJSXIdentifier(node, opts) and t.assertJSXIdentifier(node, opts).

AST Node JSXIdentifier shape:

  • name: string (required)

Aliases: JSX


jsxMemberExpression

JavaScript
t.jsxMemberExpression(object, property);

See also t.isJSXMemberExpression(node, opts) and t.assertJSXMemberExpression(node, opts).

AST Node JSXMemberExpression shape:

  • object: JSXMemberExpression | JSXIdentifier (required)
  • property: JSXIdentifier (required)

Aliases: JSX


jsxNamespacedName

JavaScript
t.jsxNamespacedName(namespace, name);

See also t.isJSXNamespacedName(node, opts) and t.assertJSXNamespacedName(node, opts).

AST Node JSXNamespacedName shape:

  • namespace: JSXIdentifier (required)
  • name: JSXIdentifier (required)

Aliases: JSX


jsxOpeningElement

JavaScript
t.jsxOpeningElement(name, attributes, selfClosing);

See also t.isJSXOpeningElement(node, opts) and t.assertJSXOpeningElement(node, opts).

AST Node JSXOpeningElement shape:

  • name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName (required)
  • attributes: Array<JSXAttribute | JSXSpreadAttribute> (required)
  • selfClosing: boolean (default: false)
  • typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (default: null, excluded from builder function)

Aliases: JSX, Immutable


jsxOpeningFragment

JavaScript
t.jsxOpeningFragment();

See also t.isJSXOpeningFragment(node, opts) and t.assertJSXOpeningFragment(node, opts).

Aliases: JSX, Immutable


jsxSpreadAttribute

JavaScript
t.jsxSpreadAttribute(argument);

See also t.isJSXSpreadAttribute(node, opts) and t.assertJSXSpreadAttribute(node, opts).

AST Node JSXSpreadAttribute shape:

  • argument: Expression (required)

Aliases: JSX


jsxSpreadChild

JavaScript
t.jsxSpreadChild(expression);

See also t.isJSXSpreadChild(node, opts) and t.assertJSXSpreadChild(node, opts).

AST Node JSXSpreadChild shape:

  • expression: Expression (required)

Aliases: JSX, Immutable


jsxText

JavaScript
t.jsxText(value);

See also t.isJSXText(node, opts) and t.assertJSXText(node, opts).

AST Node JSXText shape:

  • value: string (required)

Aliases: JSX, Immutable


labeledStatement

JavaScript
t.labeledStatement(label, body);

See also t.isLabeledStatement(node, opts) and t.assertLabeledStatement(node, opts).

AST Node LabeledStatement shape:

  • label: Identifier (required)
  • body: Statement (required)

Aliases: Standardized, Statement


logicalExpression

JavaScript
t.logicalExpression(operator, left, right);

See also t.isLogicalExpression(node, opts) and t.assertLogicalExpression(node, opts).

AST Node LogicalExpression shape:

  • operator: "||" | "&&" | "??" (required)
  • left: Expression (required)
  • right: Expression (required)

Aliases: Standardized, Binary, Expression


memberExpression

JavaScript
t.memberExpression(object, property, computed, optional);

See also t.isMemberExpression(node, opts) and t.assertMemberExpression(node, opts).

AST Node MemberExpression shape:

  • object: Expression | Super (required)
  • property: if computed then Expression else Identifier (required)
  • computed: boolean (default: false)
  • optional: true | false (default: null)

Aliases: Standardized, Expression, LVal


metaProperty

JavaScript
t.metaProperty(meta, property);

See also t.isMetaProperty(node, opts) and t.assertMetaProperty(node, opts).

AST Node MetaProperty shape:

  • meta: Identifier (required)
  • property: Identifier (required)

Aliases: Standardized, Expression


mixedTypeAnnotation

JavaScript
t.mixedTypeAnnotation();

See also t.isMixedTypeAnnotation(node, opts) and t.assertMixedTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


moduleExpression

JavaScript
t.moduleExpression(body);

See also t.isModuleExpression(node, opts) and t.assertModuleExpression(node, opts).

AST Node ModuleExpression shape:

  • body: Program (required)

Aliases: Expression


newExpression

JavaScript
t.newExpression(callee, arguments);

See also t.isNewExpression(node, opts) and t.assertNewExpression(node, opts).

AST Node NewExpression shape:

  • callee: Expression | Super | V8IntrinsicIdentifier (required)
  • arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder> (required)
  • optional: true | false (default: null, excluded from builder function)
  • typeArguments: TypeParameterInstantiation (default: null, excluded from builder function)
  • typeParameters: TSTypeParameterInstantiation (default: null, excluded from builder function)

Aliases: Standardized, Expression


noop

JavaScript
t.noop();

See also t.isNoop(node, opts) and t.assertNoop(node, opts).

Aliases: Miscellaneous


nullLiteral

JavaScript
t.nullLiteral();

See also t.isNullLiteral(node, opts) and t.assertNullLiteral(node, opts).

Aliases: Standardized, Expression, Pureish, Literal, Immutable


nullLiteralTypeAnnotation

JavaScript
t.nullLiteralTypeAnnotation();

See also t.isNullLiteralTypeAnnotation(node, opts) and t.assertNullLiteralTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


nullableTypeAnnotation

JavaScript
t.nullableTypeAnnotation(typeAnnotation);

See also t.isNullableTypeAnnotation(node, opts) and t.assertNullableTypeAnnotation(node, opts).

AST Node NullableTypeAnnotation shape:

  • typeAnnotation: FlowType (required)

Aliases: Flow, FlowType


numberLiteralTypeAnnotation

JavaScript
t.numberLiteralTypeAnnotation(value);

See also t.isNumberLiteralTypeAnnotation(node, opts) and t.assertNumberLiteralTypeAnnotation(node, opts).

AST Node NumberLiteralTypeAnnotation shape:

  • value: number (required)

Aliases: Flow, FlowType


numberTypeAnnotation

JavaScript
t.numberTypeAnnotation();

See also t.isNumberTypeAnnotation(node, opts) and t.assertNumberTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


numericLiteral

JavaScript
t.numericLiteral(value);

See also t.isNumericLiteral(node, opts) and t.assertNumericLiteral(node, opts).

AST Node NumericLiteral shape:

  • value: a non-negative finite number (required)

Aliases: Standardized, Expression, Pureish, Literal, Immutable


objectExpression

JavaScript
t.objectExpression(properties);

See also t.isObjectExpression(node, opts) and t.assertObjectExpression(node, opts).

AST Node ObjectExpression shape:

  • properties: Array<ObjectMethod | ObjectProperty | SpreadElement> (required)

Aliases: Standardized, Expression


objectMethod

JavaScript
t.objectMethod(kind, key, params, body, computed, generator, async);

See also t.isObjectMethod(node, opts) and t.assertObjectMethod(node, opts).

AST Node ObjectMethod shape:

  • kind: "method" | "get" | "set" (default: 'method')
  • key: if computed then Expression else Identifier | Literal (required)
  • params: Array<Identifier | Pattern | RestElement> (required)
  • body: BlockStatement (required)
  • computed: boolean (default: false)
  • generator: boolean (default: false)
  • async: boolean (default: false)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • returnType: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)
  • typeParameters: TypeParameterDeclaration | TSTypeParameterDeclaration | Noop (default: null, excluded from builder function)

Aliases: Standardized, UserWhitespacable, Function, Scopable, BlockParent, FunctionParent, Method, ObjectMember


objectPattern

JavaScript
t.objectPattern(properties);

See also t.isObjectPattern(node, opts) and t.assertObjectPattern(node, opts).

AST Node ObjectPattern shape:

  • properties: Array<RestElement | ObjectProperty> (required)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)

Aliases: Standardized, Pattern, PatternLike, LVal


objectProperty

JavaScript
t.objectProperty(key, value, computed, shorthand, decorators);

See also t.isObjectProperty(node, opts) and t.assertObjectProperty(node, opts).

AST Node ObjectProperty shape:

  • key: if computed then Expression else Identifier | Literal (required)
  • value: Expression | PatternLike (required)
  • computed: boolean (default: false)
  • shorthand: boolean (default: false)
  • decorators: Array<Decorator> (default: null)

Aliases: Standardized, UserWhitespacable, Property, ObjectMember


objectTypeAnnotation

JavaScript
t.objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact);

See also t.isObjectTypeAnnotation(node, opts) and t.assertObjectTypeAnnotation(node, opts).

AST Node ObjectTypeAnnotation shape:

  • properties: Array<ObjectTypeProperty | ObjectTypeSpreadProperty> (required)
  • indexers: Array<ObjectTypeIndexer> (default: [])
  • callProperties: Array<ObjectTypeCallProperty> (default: [])
  • internalSlots: Array<ObjectTypeInternalSlot> (default: [])
  • exact: boolean (default: false)
  • inexact: boolean (default: null, excluded from builder function)

Aliases: Flow, FlowType


objectTypeCallProperty

JavaScript
t.objectTypeCallProperty(value);

See also t.isObjectTypeCallProperty(node, opts) and t.assertObjectTypeCallProperty(node, opts).

AST Node ObjectTypeCallProperty shape:

  • value: FlowType (required)
  • static: boolean (required)

Aliases: Flow, UserWhitespacable


objectTypeIndexer

JavaScript
t.objectTypeIndexer(id, key, value, variance);

See also t.isObjectTypeIndexer(node, opts) and t.assertObjectTypeIndexer(node, opts).

AST Node ObjectTypeIndexer shape:

  • id: Identifier (default: null)
  • key: FlowType (required)
  • value: FlowType (required)
  • variance: Variance (default: null)
  • static: boolean (required)

Aliases: Flow, UserWhitespacable


objectTypeInternalSlot

JavaScript
t.objectTypeInternalSlot(id, value, optional, static, method);

See also t.isObjectTypeInternalSlot(node, opts) and t.assertObjectTypeInternalSlot(node, opts).

AST Node ObjectTypeInternalSlot shape:

  • id: Identifier (required)
  • value: FlowType (required)
  • optional: boolean (required)
  • static: boolean (required)
  • method: boolean (required)

Aliases: Flow, UserWhitespacable


objectTypeProperty

JavaScript
t.objectTypeProperty(key, value, variance);

See also t.isObjectTypeProperty(node, opts) and t.assertObjectTypeProperty(node, opts).

AST Node ObjectTypeProperty shape:

  • key: Identifier | StringLiteral (required)
  • value: FlowType (required)
  • variance: Variance (default: null)
  • kind: "init" | "get" | "set" (required)
  • method: boolean (required)
  • optional: boolean (required)
  • proto: boolean (required)
  • static: boolean (required)

Aliases: Flow, UserWhitespacable


objectTypeSpreadProperty

JavaScript
t.objectTypeSpreadProperty(argument);

See also t.isObjectTypeSpreadProperty(node, opts) and t.assertObjectTypeSpreadProperty(node, opts).

AST Node ObjectTypeSpreadProperty shape:

  • argument: FlowType (required)

Aliases: Flow, UserWhitespacable


opaqueType

JavaScript
t.opaqueType(id, typeParameters, supertype, impltype);

See also t.isOpaqueType(node, opts) and t.assertOpaqueType(node, opts).

AST Node OpaqueType shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • supertype: FlowType (default: null)
  • impltype: FlowType (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


optionalCallExpression

JavaScript
t.optionalCallExpression(callee, arguments, optional);

See also t.isOptionalCallExpression(node, opts) and t.assertOptionalCallExpression(node, opts).

AST Node OptionalCallExpression shape:

  • callee: Expression (required)
  • arguments: Array<Expression | SpreadElement | JSXNamespacedName | ArgumentPlaceholder> (required)
  • optional: boolean (required)
  • typeArguments: TypeParameterInstantiation (default: null, excluded from builder function)
  • typeParameters: TSTypeParameterInstantiation (default: null, excluded from builder function)

Aliases: Standardized, Expression


optionalIndexedAccessType

JavaScript
t.optionalIndexedAccessType(objectType, indexType);

See also t.isOptionalIndexedAccessType(node, opts) and t.assertOptionalIndexedAccessType(node, opts).

AST Node OptionalIndexedAccessType shape:

  • objectType: FlowType (required)
  • indexType: FlowType (required)
  • optional: boolean (required)

Aliases: Flow, FlowType


optionalMemberExpression

JavaScript
t.optionalMemberExpression(object, property, computed, optional);

See also t.isOptionalMemberExpression(node, opts) and t.assertOptionalMemberExpression(node, opts).

AST Node OptionalMemberExpression shape:

  • object: Expression (required)
  • property: Expression | Identifier (required)
  • computed: boolean (default: false)
  • optional: boolean (required)

Aliases: Standardized, Expression


parenthesizedExpression

JavaScript
t.parenthesizedExpression(expression);

See also t.isParenthesizedExpression(node, opts) and t.assertParenthesizedExpression(node, opts).

AST Node ParenthesizedExpression shape:

  • expression: Expression (required)

Aliases: Standardized, Expression, ExpressionWrapper


pipelineBareFunction

JavaScript
t.pipelineBareFunction(callee);

See also t.isPipelineBareFunction(node, opts) and t.assertPipelineBareFunction(node, opts).

AST Node PipelineBareFunction shape:

  • callee: Expression (required)

Aliases: Expression


pipelinePrimaryTopicReference

JavaScript
t.pipelinePrimaryTopicReference();

See also t.isPipelinePrimaryTopicReference(node, opts) and t.assertPipelinePrimaryTopicReference(node, opts).

Aliases: Expression


pipelineTopicExpression

JavaScript
t.pipelineTopicExpression(expression);

See also t.isPipelineTopicExpression(node, opts) and t.assertPipelineTopicExpression(node, opts).

AST Node PipelineTopicExpression shape:

  • expression: Expression (required)

Aliases: Expression


placeholder

JavaScript
t.placeholder(expectedNode, name);

See also t.isPlaceholder(node, opts) and t.assertPlaceholder(node, opts).

AST Node Placeholder shape:

  • expectedNode: "Identifier" | "StringLiteral" | "Expression" | "Statement" | "Declaration" | "BlockStatement" | "ClassBody" | "Pattern" (required)
  • name: Identifier (required)

Aliases: Miscellaneous


privateName

JavaScript
t.privateName(id);

See also t.isPrivateName(node, opts) and t.assertPrivateName(node, opts).

AST Node PrivateName shape:

  • id: Identifier (required)

Aliases: Standardized, Private


program

JavaScript
t.program(body, directives, sourceType, interpreter);

See also t.isProgram(node, opts) and t.assertProgram(node, opts).

AST Node Program shape:

  • body: Array<Statement> (required)
  • directives: Array<Directive> (default: [])
  • sourceType: "script" | "module" (default: 'script')
  • interpreter: InterpreterDirective (default: null)

Aliases: Standardized, Scopable, BlockParent, Block


qualifiedTypeIdentifier

JavaScript
t.qualifiedTypeIdentifier(id, qualification);

See also t.isQualifiedTypeIdentifier(node, opts) and t.assertQualifiedTypeIdentifier(node, opts).

AST Node QualifiedTypeIdentifier shape:

  • id: Identifier (required)
  • qualification: Identifier | QualifiedTypeIdentifier (required)

Aliases: Flow


recordExpression

JavaScript
t.recordExpression(properties);

See also t.isRecordExpression(node, opts) and t.assertRecordExpression(node, opts).

AST Node RecordExpression shape:

  • properties: Array<ObjectProperty | SpreadElement> (required)

Aliases: Expression


regExpLiteral

JavaScript
t.regExpLiteral(pattern, flags);

See also t.isRegExpLiteral(node, opts) and t.assertRegExpLiteral(node, opts).

AST Node RegExpLiteral shape:

  • pattern: string (required)
  • flags: string (default: '')

Aliases: Standardized, Expression, Pureish, Literal


restElement

JavaScript
t.restElement(argument);

See also t.isRestElement(node, opts) and t.assertRestElement(node, opts).

AST Node RestElement shape:

  • argument: LVal (required)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • typeAnnotation: TypeAnnotation | TSTypeAnnotation | Noop (default: null, excluded from builder function)

Aliases: Standardized, LVal, PatternLike


returnStatement

JavaScript
t.returnStatement(argument);

See also t.isReturnStatement(node, opts) and t.assertReturnStatement(node, opts).

AST Node ReturnStatement shape:

  • argument: Expression (default: null)

Aliases: Standardized, Statement, Terminatorless, CompletionStatement


sequenceExpression

JavaScript
t.sequenceExpression(expressions);

See also t.isSequenceExpression(node, opts) and t.assertSequenceExpression(node, opts).

AST Node SequenceExpression shape:

  • expressions: Array<Expression> (required)

Aliases: Standardized, Expression


spreadElement

JavaScript
t.spreadElement(argument);

See also t.isSpreadElement(node, opts) and t.assertSpreadElement(node, opts).

AST Node SpreadElement shape:

  • argument: Expression (required)

Aliases: Standardized, UnaryLike


staticBlock

JavaScript
t.staticBlock(body);

See also t.isStaticBlock(node, opts) and t.assertStaticBlock(node, opts).

AST Node StaticBlock shape:

  • body: Array<Statement> (required)

Aliases: Standardized, Scopable, BlockParent, FunctionParent


stringLiteral

JavaScript
t.stringLiteral(value);

See also t.isStringLiteral(node, opts) and t.assertStringLiteral(node, opts).

AST Node StringLiteral shape:

  • value: string (required)

Aliases: Standardized, Expression, Pureish, Literal, Immutable


stringLiteralTypeAnnotation

JavaScript
t.stringLiteralTypeAnnotation(value);

See also t.isStringLiteralTypeAnnotation(node, opts) and t.assertStringLiteralTypeAnnotation(node, opts).

AST Node StringLiteralTypeAnnotation shape:

  • value: string (required)

Aliases: Flow, FlowType


stringTypeAnnotation

JavaScript
t.stringTypeAnnotation();

See also t.isStringTypeAnnotation(node, opts) and t.assertStringTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


super

JavaScript
t.super();

See also t.isSuper(node, opts) and t.assertSuper(node, opts).

Aliases: Standardized, Expression


switchCase

JavaScript
t.switchCase(test, consequent);

See also t.isSwitchCase(node, opts) and t.assertSwitchCase(node, opts).

AST Node SwitchCase shape:

  • test: Expression (default: null)
  • consequent: Array<Statement> (required)

Aliases: Standardized


switchStatement

JavaScript
t.switchStatement(discriminant, cases);

See also t.isSwitchStatement(node, opts) and t.assertSwitchStatement(node, opts).

AST Node SwitchStatement shape:

  • discriminant: Expression (required)
  • cases: Array<SwitchCase> (required)

Aliases: Standardized, Statement, BlockParent, Scopable


symbolTypeAnnotation

JavaScript
t.symbolTypeAnnotation();

See also t.isSymbolTypeAnnotation(node, opts) and t.assertSymbolTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


tsAnyKeyword

JavaScript
t.tsAnyKeyword();

See also t.isTSAnyKeyword(node, opts) and t.assertTSAnyKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsArrayType

JavaScript
t.tsArrayType(elementType);

See also t.isTSArrayType(node, opts) and t.assertTSArrayType(node, opts).

AST Node TSArrayType shape:

  • elementType: TSType (required)

Aliases: TypeScript, TSType


tsAsExpression

JavaScript
t.tsAsExpression(expression, typeAnnotation);

See also t.isTSAsExpression(node, opts) and t.assertTSAsExpression(node, opts).

AST Node TSAsExpression shape:

  • expression: Expression (required)
  • typeAnnotation: TSType (required)

Aliases: TypeScript, Expression, LVal, PatternLike


tsBigIntKeyword

JavaScript
t.tsBigIntKeyword();

See also t.isTSBigIntKeyword(node, opts) and t.assertTSBigIntKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsBooleanKeyword

JavaScript
t.tsBooleanKeyword();

See also t.isTSBooleanKeyword(node, opts) and t.assertTSBooleanKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsCallSignatureDeclaration

JavaScript
t.tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation);

See also t.isTSCallSignatureDeclaration(node, opts) and t.assertTSCallSignatureDeclaration(node, opts).

AST Node TSCallSignatureDeclaration shape:

  • typeParameters: TSTypeParameterDeclaration (default: null)
  • parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)

Aliases: TypeScript, TSTypeElement


tsConditionalType

JavaScript
t.tsConditionalType(checkType, extendsType, trueType, falseType);

See also t.isTSConditionalType(node, opts) and t.assertTSConditionalType(node, opts).

AST Node TSConditionalType shape:

  • checkType: TSType (required)
  • extendsType: TSType (required)
  • trueType: TSType (required)
  • falseType: TSType (required)

Aliases: TypeScript, TSType


tsConstructSignatureDeclaration

JavaScript
t.tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation);

See also t.isTSConstructSignatureDeclaration(node, opts) and t.assertTSConstructSignatureDeclaration(node, opts).

AST Node TSConstructSignatureDeclaration shape:

  • typeParameters: TSTypeParameterDeclaration (default: null)
  • parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)

Aliases: TypeScript, TSTypeElement


tsConstructorType

JavaScript
t.tsConstructorType(typeParameters, parameters, typeAnnotation);

See also t.isTSConstructorType(node, opts) and t.assertTSConstructorType(node, opts).

AST Node TSConstructorType shape:

  • typeParameters: TSTypeParameterDeclaration (default: null)
  • parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)
  • abstract: boolean (default: null, excluded from builder function)

Aliases: TypeScript, TSType


tsDeclareFunction

JavaScript
t.tsDeclareFunction(id, typeParameters, params, returnType);

See also t.isTSDeclareFunction(node, opts) and t.assertTSDeclareFunction(node, opts).

AST Node TSDeclareFunction shape:

  • id: Identifier (default: null)
  • typeParameters: TSTypeParameterDeclaration | Noop (default: null)
  • params: Array<Identifier | Pattern | RestElement> (required)
  • returnType: TSTypeAnnotation | Noop (default: null)
  • async: boolean (default: false, excluded from builder function)
  • declare: boolean (default: null, excluded from builder function)
  • generator: boolean (default: false, excluded from builder function)

Aliases: TypeScript, Statement, Declaration


tsDeclareMethod

JavaScript
t.tsDeclareMethod(decorators, key, typeParameters, params, returnType);

See also t.isTSDeclareMethod(node, opts) and t.assertTSDeclareMethod(node, opts).

AST Node TSDeclareMethod shape:

  • decorators: Array<Decorator> (default: null)
  • key: Identifier | StringLiteral | NumericLiteral | BigIntLiteral | Expression (required)
  • typeParameters: TSTypeParameterDeclaration | Noop (default: null)
  • params: Array<Identifier | Pattern | RestElement | TSParameterProperty> (required)
  • returnType: TSTypeAnnotation | Noop (default: null)
  • abstract: boolean (default: null, excluded from builder function)
  • access: "public" | "private" | "protected" (default: null, excluded from builder function)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • async: boolean (default: false, excluded from builder function)
  • computed: boolean (default: false, excluded from builder function)
  • generator: boolean (default: false, excluded from builder function)
  • kind: "get" | "set" | "method" | "constructor" (default: 'method', excluded from builder function)
  • optional: boolean (default: null, excluded from builder function)
  • override: boolean (default: false, excluded from builder function)
  • static: boolean (default: false, excluded from builder function)

Aliases: TypeScript


tsEnumDeclaration

JavaScript
t.tsEnumDeclaration(id, members);

See also t.isTSEnumDeclaration(node, opts) and t.assertTSEnumDeclaration(node, opts).

AST Node TSEnumDeclaration shape:

  • id: Identifier (required)
  • members: Array<TSEnumMember> (required)
  • const: boolean (default: null, excluded from builder function)
  • declare: boolean (default: null, excluded from builder function)
  • initializer: Expression (default: null, excluded from builder function)

Aliases: TypeScript, Statement, Declaration


tsEnumMember

JavaScript
t.tsEnumMember(id, initializer);

See also t.isTSEnumMember(node, opts) and t.assertTSEnumMember(node, opts).

AST Node TSEnumMember shape:

  • id: Identifier | StringLiteral (required)
  • initializer: Expression (default: null)

Aliases: TypeScript


tsExportAssignment

JavaScript
t.tsExportAssignment(expression);

See also t.isTSExportAssignment(node, opts) and t.assertTSExportAssignment(node, opts).

AST Node TSExportAssignment shape:

  • expression: Expression (required)

Aliases: TypeScript, Statement


tsExpressionWithTypeArguments

JavaScript
t.tsExpressionWithTypeArguments(expression, typeParameters);

See also t.isTSExpressionWithTypeArguments(node, opts) and t.assertTSExpressionWithTypeArguments(node, opts).

AST Node TSExpressionWithTypeArguments shape:

  • expression: TSEntityName (required)
  • typeParameters: TSTypeParameterInstantiation (default: null)

Aliases: TypeScript, TSType


tsExternalModuleReference

JavaScript
t.tsExternalModuleReference(expression);

See also t.isTSExternalModuleReference(node, opts) and t.assertTSExternalModuleReference(node, opts).

AST Node TSExternalModuleReference shape:

  • expression: StringLiteral (required)

Aliases: TypeScript


tsFunctionType

JavaScript
t.tsFunctionType(typeParameters, parameters, typeAnnotation);

See also t.isTSFunctionType(node, opts) and t.assertTSFunctionType(node, opts).

AST Node TSFunctionType shape:

  • typeParameters: TSTypeParameterDeclaration (default: null)
  • parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)

Aliases: TypeScript, TSType


tsImportEqualsDeclaration

JavaScript
t.tsImportEqualsDeclaration(id, moduleReference);

See also t.isTSImportEqualsDeclaration(node, opts) and t.assertTSImportEqualsDeclaration(node, opts).

AST Node TSImportEqualsDeclaration shape:

  • id: Identifier (required)
  • moduleReference: TSEntityName | TSExternalModuleReference (required)
  • importKind: "type" | "value" (default: null, excluded from builder function)
  • isExport: boolean (required)

Aliases: TypeScript, Statement


tsImportType

JavaScript
t.tsImportType(argument, qualifier, typeParameters);

See also t.isTSImportType(node, opts) and t.assertTSImportType(node, opts).

AST Node TSImportType shape:

  • argument: StringLiteral (required)
  • qualifier: TSEntityName (default: null)
  • typeParameters: TSTypeParameterInstantiation (default: null)

Aliases: TypeScript, TSType


tsIndexSignature

JavaScript
t.tsIndexSignature(parameters, typeAnnotation);

See also t.isTSIndexSignature(node, opts) and t.assertTSIndexSignature(node, opts).

AST Node TSIndexSignature shape:

  • parameters: Array<Identifier> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)
  • readonly: boolean (default: null, excluded from builder function)
  • static: boolean (default: null, excluded from builder function)

Aliases: TypeScript, TSTypeElement


tsIndexedAccessType

JavaScript
t.tsIndexedAccessType(objectType, indexType);

See also t.isTSIndexedAccessType(node, opts) and t.assertTSIndexedAccessType(node, opts).

AST Node TSIndexedAccessType shape:

  • objectType: TSType (required)
  • indexType: TSType (required)

Aliases: TypeScript, TSType


tsInferType

JavaScript
t.tsInferType(typeParameter);

See also t.isTSInferType(node, opts) and t.assertTSInferType(node, opts).

AST Node TSInferType shape:

  • typeParameter: TSTypeParameter (required)

Aliases: TypeScript, TSType


tsInstantiationExpression

JavaScript
t.tsInstantiationExpression(expression, typeParameters);

See also t.isTSInstantiationExpression(node, opts) and t.assertTSInstantiationExpression(node, opts).

AST Node TSInstantiationExpression shape:

  • expression: Expression (required)
  • typeParameters: TSTypeParameterInstantiation (default: null)

Aliases: TypeScript, Expression


tsInterfaceBody

JavaScript
t.tsInterfaceBody(body);

See also t.isTSInterfaceBody(node, opts) and t.assertTSInterfaceBody(node, opts).

AST Node TSInterfaceBody shape:

  • body: Array<TSTypeElement> (required)

Aliases: TypeScript


tsInterfaceDeclaration

JavaScript
t.tsInterfaceDeclaration(id, typeParameters, extends, body);

See also t.isTSInterfaceDeclaration(node, opts) and t.assertTSInterfaceDeclaration(node, opts).

AST Node TSInterfaceDeclaration shape:

  • id: Identifier (required)
  • typeParameters: TSTypeParameterDeclaration (default: null)
  • extends: Array<TSExpressionWithTypeArguments> (default: null)
  • body: TSInterfaceBody (required)
  • declare: boolean (default: null, excluded from builder function)

Aliases: TypeScript, Statement, Declaration


tsIntersectionType

JavaScript
t.tsIntersectionType(types);

See also t.isTSIntersectionType(node, opts) and t.assertTSIntersectionType(node, opts).

AST Node TSIntersectionType shape:

  • types: Array<TSType> (required)

Aliases: TypeScript, TSType


tsIntrinsicKeyword

JavaScript
t.tsIntrinsicKeyword();

See also t.isTSIntrinsicKeyword(node, opts) and t.assertTSIntrinsicKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsLiteralType

JavaScript
t.tsLiteralType(literal);

See also t.isTSLiteralType(node, opts) and t.assertTSLiteralType(node, opts).

AST Node TSLiteralType shape:

  • literal: NumericLiteral | StringLiteral | BooleanLiteral | BigIntLiteral | TemplateLiteral | UnaryExpression (required)

Aliases: TypeScript, TSType, TSBaseType


tsMappedType

JavaScript
t.tsMappedType(typeParameter, typeAnnotation, nameType);

See also t.isTSMappedType(node, opts) and t.assertTSMappedType(node, opts).

AST Node TSMappedType shape:

  • typeParameter: TSTypeParameter (required)
  • typeAnnotation: TSType (default: null)
  • nameType: TSType (default: null)
  • optional: true | false | "+" | "-" (default: null, excluded from builder function)
  • readonly: true | false | "+" | "-" (default: null, excluded from builder function)

Aliases: TypeScript, TSType


tsMethodSignature

JavaScript
t.tsMethodSignature(key, typeParameters, parameters, typeAnnotation);

See also t.isTSMethodSignature(node, opts) and t.assertTSMethodSignature(node, opts).

AST Node TSMethodSignature shape:

  • key: Expression (required)
  • typeParameters: TSTypeParameterDeclaration (default: null)
  • parameters: Array<ArrayPattern | Identifier | ObjectPattern | RestElement> (required)
  • typeAnnotation: TSTypeAnnotation (default: null)
  • computed: boolean (default: false, excluded from builder function)
  • kind: "method" | "get" | "set" (required)
  • optional: boolean (default: null, excluded from builder function)

Aliases: TypeScript, TSTypeElement


tsModuleBlock

JavaScript
t.tsModuleBlock(body);

See also t.isTSModuleBlock(node, opts) and t.assertTSModuleBlock(node, opts).

AST Node TSModuleBlock shape:

  • body: Array<Statement> (required)

Aliases: TypeScript, Scopable, Block, BlockParent, FunctionParent


tsModuleDeclaration

JavaScript
t.tsModuleDeclaration(id, body);

See also t.isTSModuleDeclaration(node, opts) and t.assertTSModuleDeclaration(node, opts).

AST Node TSModuleDeclaration shape:

  • id: Identifier | StringLiteral (required)
  • body: TSModuleBlock | TSModuleDeclaration (required)
  • declare: boolean (default: null, excluded from builder function)
  • global: boolean (default: null, excluded from builder function)

Aliases: TypeScript, Statement, Declaration


tsNamedTupleMember

JavaScript
t.tsNamedTupleMember(label, elementType, optional);

See also t.isTSNamedTupleMember(node, opts) and t.assertTSNamedTupleMember(node, opts).

AST Node TSNamedTupleMember shape:

  • label: Identifier (required)
  • elementType: TSType (required)
  • optional: boolean (default: false)

Aliases: TypeScript


tsNamespaceExportDeclaration

JavaScript
t.tsNamespaceExportDeclaration(id);

See also t.isTSNamespaceExportDeclaration(node, opts) and t.assertTSNamespaceExportDeclaration(node, opts).

AST Node TSNamespaceExportDeclaration shape:

  • id: Identifier (required)

Aliases: TypeScript, Statement


tsNeverKeyword

JavaScript
t.tsNeverKeyword();

See also t.isTSNeverKeyword(node, opts) and t.assertTSNeverKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsNonNullExpression

JavaScript
t.tsNonNullExpression(expression);

See also t.isTSNonNullExpression(node, opts) and t.assertTSNonNullExpression(node, opts).

AST Node TSNonNullExpression shape:

  • expression: Expression (required)

Aliases: TypeScript, Expression, LVal, PatternLike


tsNullKeyword

JavaScript
t.tsNullKeyword();

See also t.isTSNullKeyword(node, opts) and t.assertTSNullKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsNumberKeyword

JavaScript
t.tsNumberKeyword();

See also t.isTSNumberKeyword(node, opts) and t.assertTSNumberKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsObjectKeyword

JavaScript
t.tsObjectKeyword();

See also t.isTSObjectKeyword(node, opts) and t.assertTSObjectKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsOptionalType

JavaScript
t.tsOptionalType(typeAnnotation);

See also t.isTSOptionalType(node, opts) and t.assertTSOptionalType(node, opts).

AST Node TSOptionalType shape:

  • typeAnnotation: TSType (required)

Aliases: TypeScript, TSType


tsParameterProperty

JavaScript
t.tsParameterProperty(parameter);

See also t.isTSParameterProperty(node, opts) and t.assertTSParameterProperty(node, opts).

AST Node TSParameterProperty shape:

  • parameter: Identifier | AssignmentPattern (required)
  • accessibility: "public" | "private" | "protected" (default: null, excluded from builder function)
  • decorators: Array<Decorator> (default: null, excluded from builder function)
  • override: boolean (default: null, excluded from builder function)
  • readonly: boolean (default: null, excluded from builder function)

Aliases: TypeScript, LVal


tsParenthesizedType

JavaScript
t.tsParenthesizedType(typeAnnotation);

See also t.isTSParenthesizedType(node, opts) and t.assertTSParenthesizedType(node, opts).

AST Node TSParenthesizedType shape:

  • typeAnnotation: TSType (required)

Aliases: TypeScript, TSType


tsPropertySignature

JavaScript
t.tsPropertySignature(key, typeAnnotation);

See also t.isTSPropertySignature(node, opts) and t.assertTSPropertySignature(node, opts).

AST Node TSPropertySignature shape:

  • key: Expression (required)
  • typeAnnotation: TSTypeAnnotation (default: null)
  • computed: boolean (default: false, excluded from builder function)
  • kind: "get" | "set" (required)
  • optional: boolean (default: null, excluded from builder function)
  • readonly: boolean (default: null, excluded from builder function)

Aliases: TypeScript, TSTypeElement


tsQualifiedName

JavaScript
t.tsQualifiedName(left, right);

See also t.isTSQualifiedName(node, opts) and t.assertTSQualifiedName(node, opts).

AST Node TSQualifiedName shape:

  • left: TSEntityName (required)
  • right: Identifier (required)

Aliases: TypeScript, TSEntityName


tsRestType

JavaScript
t.tsRestType(typeAnnotation);

See also t.isTSRestType(node, opts) and t.assertTSRestType(node, opts).

AST Node TSRestType shape:

  • typeAnnotation: TSType (required)

Aliases: TypeScript, TSType


tsSatisfiesExpression

JavaScript
t.tsSatisfiesExpression(expression, typeAnnotation);
History
VersionChanges
v7.20.0Introduced

See also t.isTSSatisfiesExpression(node, opts) and t.assertTSSatisfiesExpression(node, opts).

AST Node TSSatisfiesExpression shape:

  • expression: Expression (required)
  • typeAnnotation: TSType (required)

Aliases: TypeScript, Expression, LVal, PatternLike


tsStringKeyword

JavaScript
t.tsStringKeyword();

See also t.isTSStringKeyword(node, opts) and t.assertTSStringKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsSymbolKeyword

JavaScript
t.tsSymbolKeyword();

See also t.isTSSymbolKeyword(node, opts) and t.assertTSSymbolKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsThisType

JavaScript
t.tsThisType();

See also t.isTSThisType(node, opts) and t.assertTSThisType(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsTupleType

JavaScript
t.tsTupleType(elementTypes);

See also t.isTSTupleType(node, opts) and t.assertTSTupleType(node, opts).

AST Node TSTupleType shape:

  • elementTypes: Array<TSType | TSNamedTupleMember> (required)

Aliases: TypeScript, TSType


tsTypeAliasDeclaration

JavaScript
t.tsTypeAliasDeclaration(id, typeParameters, typeAnnotation);

See also t.isTSTypeAliasDeclaration(node, opts) and t.assertTSTypeAliasDeclaration(node, opts).

AST Node TSTypeAliasDeclaration shape:

  • id: Identifier (required)
  • typeParameters: TSTypeParameterDeclaration (default: null)
  • typeAnnotation: TSType (required)
  • declare: boolean (default: null, excluded from builder function)

Aliases: TypeScript, Statement, Declaration


tsTypeAnnotation

JavaScript
t.tsTypeAnnotation(typeAnnotation);

See also t.isTSTypeAnnotation(node, opts) and t.assertTSTypeAnnotation(node, opts).

AST Node TSTypeAnnotation shape:

  • typeAnnotation: TSType (required)

Aliases: TypeScript


tsTypeAssertion

JavaScript
t.tsTypeAssertion(typeAnnotation, expression);

See also t.isTSTypeAssertion(node, opts) and t.assertTSTypeAssertion(node, opts).

AST Node TSTypeAssertion shape:

  • typeAnnotation: TSType (required)
  • expression: Expression (required)

Aliases: TypeScript, Expression, LVal, PatternLike


tsTypeLiteral

JavaScript
t.tsTypeLiteral(members);

See also t.isTSTypeLiteral(node, opts) and t.assertTSTypeLiteral(node, opts).

AST Node TSTypeLiteral shape:

  • members: Array<TSTypeElement> (required)

Aliases: TypeScript, TSType


tsTypeOperator

JavaScript
t.tsTypeOperator(typeAnnotation);

See also t.isTSTypeOperator(node, opts) and t.assertTSTypeOperator(node, opts).

AST Node TSTypeOperator shape:

  • typeAnnotation: TSType (required)
  • operator: string (required)

Aliases: TypeScript, TSType


tsTypeParameter

JavaScript
t.tsTypeParameter(constraint, default, name);
History
VersionChanges
v7.21.0Supports const

See also t.isTSTypeParameter(node, opts) and t.assertTSTypeParameter(node, opts).

AST Node TSTypeParameter shape:

  • constraint: TSType (default: null)
  • default: TSType (default: null)
  • name: string (required)
  • const: boolean (default: null, excluded from builder function)
  • in: boolean (default: null, excluded from builder function)
  • out: boolean (default: null, excluded from builder function)

Aliases: TypeScript


tsTypeParameterDeclaration

JavaScript
t.tsTypeParameterDeclaration(params);

See also t.isTSTypeParameterDeclaration(node, opts) and t.assertTSTypeParameterDeclaration(node, opts).

AST Node TSTypeParameterDeclaration shape:

  • params: Array<TSTypeParameter> (required)

Aliases: TypeScript


tsTypeParameterInstantiation

JavaScript
t.tsTypeParameterInstantiation(params);

See also t.isTSTypeParameterInstantiation(node, opts) and t.assertTSTypeParameterInstantiation(node, opts).

AST Node TSTypeParameterInstantiation shape:

  • params: Array<TSType> (required)

Aliases: TypeScript


tsTypePredicate

JavaScript
t.tsTypePredicate(parameterName, typeAnnotation, asserts);

See also t.isTSTypePredicate(node, opts) and t.assertTSTypePredicate(node, opts).

AST Node TSTypePredicate shape:

  • parameterName: Identifier | TSThisType (required)
  • typeAnnotation: TSTypeAnnotation (default: null)
  • asserts: boolean (default: null)

Aliases: TypeScript, TSType


tsTypeQuery

JavaScript
t.tsTypeQuery(exprName, typeParameters);

See also t.isTSTypeQuery(node, opts) and t.assertTSTypeQuery(node, opts).

AST Node TSTypeQuery shape:

  • exprName: TSEntityName | TSImportType (required)
  • typeParameters: TSTypeParameterInstantiation (default: null)

Aliases: TypeScript, TSType


tsTypeReference

JavaScript
t.tsTypeReference(typeName, typeParameters);

See also t.isTSTypeReference(node, opts) and t.assertTSTypeReference(node, opts).

AST Node TSTypeReference shape:

  • typeName: TSEntityName (required)
  • typeParameters: TSTypeParameterInstantiation (default: null)

Aliases: TypeScript, TSType


tsUndefinedKeyword

JavaScript
t.tsUndefinedKeyword();

See also t.isTSUndefinedKeyword(node, opts) and t.assertTSUndefinedKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsUnionType

JavaScript
t.tsUnionType(types);

See also t.isTSUnionType(node, opts) and t.assertTSUnionType(node, opts).

AST Node TSUnionType shape:

  • types: Array<TSType> (required)

Aliases: TypeScript, TSType


tsUnknownKeyword

JavaScript
t.tsUnknownKeyword();

See also t.isTSUnknownKeyword(node, opts) and t.assertTSUnknownKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


tsVoidKeyword

JavaScript
t.tsVoidKeyword();

See also t.isTSVoidKeyword(node, opts) and t.assertTSVoidKeyword(node, opts).

Aliases: TypeScript, TSType, TSBaseType


taggedTemplateExpression

JavaScript
t.taggedTemplateExpression(tag, quasi);

See also t.isTaggedTemplateExpression(node, opts) and t.assertTaggedTemplateExpression(node, opts).

AST Node TaggedTemplateExpression shape:

  • tag: Expression (required)
  • quasi: TemplateLiteral (required)
  • typeParameters: TypeParameterInstantiation | TSTypeParameterInstantiation (default: null, excluded from builder function)

Aliases: Standardized, Expression


templateElement

JavaScript
t.templateElement(value, tail);

See also t.isTemplateElement(node, opts) and t.assertTemplateElement(node, opts).

AST Node TemplateElement shape:

  • value: { raw: string, cooked?: string } (required)
  • tail: boolean (default: false)

Aliases: Standardized


templateLiteral

JavaScript
t.templateLiteral(quasis, expressions);

See also t.isTemplateLiteral(node, opts) and t.assertTemplateLiteral(node, opts).

AST Node TemplateLiteral shape:

  • quasis: Array<TemplateElement> (required)
  • expressions: Array<Expression | TSType> (required)

Aliases: Standardized, Expression, Literal


thisExpression

JavaScript
t.thisExpression();

See also t.isThisExpression(node, opts) and t.assertThisExpression(node, opts).

Aliases: Standardized, Expression


thisTypeAnnotation

JavaScript
t.thisTypeAnnotation();

See also t.isThisTypeAnnotation(node, opts) and t.assertThisTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


throwStatement

JavaScript
t.throwStatement(argument);

See also t.isThrowStatement(node, opts) and t.assertThrowStatement(node, opts).

AST Node ThrowStatement shape:

  • argument: Expression (required)

Aliases: Standardized, Statement, Terminatorless, CompletionStatement


topicReference

JavaScript
t.topicReference();

See also t.isTopicReference(node, opts) and t.assertTopicReference(node, opts).

Aliases: Expression


tryStatement

JavaScript
t.tryStatement(block, handler, finalizer);

See also t.isTryStatement(node, opts) and t.assertTryStatement(node, opts).

AST Node TryStatement shape:

  • block: BlockStatement (required)
  • handler: CatchClause (default: null)
  • finalizer: BlockStatement (default: null)

Aliases: Standardized, Statement


tupleExpression

JavaScript
t.tupleExpression(elements);

See also t.isTupleExpression(node, opts) and t.assertTupleExpression(node, opts).

AST Node TupleExpression shape:

  • elements: Array<Expression | SpreadElement> (default: [])

Aliases: Expression


tupleTypeAnnotation

JavaScript
t.tupleTypeAnnotation(types);

See also t.isTupleTypeAnnotation(node, opts) and t.assertTupleTypeAnnotation(node, opts).

AST Node TupleTypeAnnotation shape:

  • types: Array<FlowType> (required)

Aliases: Flow, FlowType


typeAlias

JavaScript
t.typeAlias(id, typeParameters, right);

See also t.isTypeAlias(node, opts) and t.assertTypeAlias(node, opts).

AST Node TypeAlias shape:

  • id: Identifier (required)
  • typeParameters: TypeParameterDeclaration (default: null)
  • right: FlowType (required)

Aliases: Flow, FlowDeclaration, Statement, Declaration


typeAnnotation

JavaScript
t.typeAnnotation(typeAnnotation);

See also t.isTypeAnnotation(node, opts) and t.assertTypeAnnotation(node, opts).

AST Node TypeAnnotation shape:

  • typeAnnotation: FlowType (required)

Aliases: Flow


typeCastExpression

JavaScript
t.typeCastExpression(expression, typeAnnotation);

See also t.isTypeCastExpression(node, opts) and t.assertTypeCastExpression(node, opts).

AST Node TypeCastExpression shape:

  • expression: Expression (required)
  • typeAnnotation: TypeAnnotation (required)

Aliases: Flow, ExpressionWrapper, Expression


typeParameter

JavaScript
t.typeParameter(bound, default, variance);

See also t.isTypeParameter(node, opts) and t.assertTypeParameter(node, opts).

AST Node TypeParameter shape:

  • bound: TypeAnnotation (default: null)
  • default: FlowType (default: null)
  • variance: Variance (default: null)
  • name: string (required)

Aliases: Flow


typeParameterDeclaration

JavaScript
t.typeParameterDeclaration(params);

See also t.isTypeParameterDeclaration(node, opts) and t.assertTypeParameterDeclaration(node, opts).

AST Node TypeParameterDeclaration shape:

  • params: Array<TypeParameter> (required)

Aliases: Flow


typeParameterInstantiation

JavaScript
t.typeParameterInstantiation(params);

See also t.isTypeParameterInstantiation(node, opts) and t.assertTypeParameterInstantiation(node, opts).

AST Node TypeParameterInstantiation shape:

  • params: Array<FlowType> (required)

Aliases: Flow


typeofTypeAnnotation

JavaScript
t.typeofTypeAnnotation(argument);

See also t.isTypeofTypeAnnotation(node, opts) and t.assertTypeofTypeAnnotation(node, opts).

AST Node TypeofTypeAnnotation shape:

  • argument: FlowType (required)

Aliases: Flow, FlowType


unaryExpression

JavaScript
t.unaryExpression(operator, argument, prefix);

See also t.isUnaryExpression(node, opts) and t.assertUnaryExpression(node, opts).

AST Node UnaryExpression shape:

  • operator: "void" | "throw" | "delete" | "!" | "+" | "-" | "~" | "typeof" (required)
  • argument: Expression (required)
  • prefix: boolean (default: true)

Aliases: Standardized, UnaryLike, Expression


unionTypeAnnotation

JavaScript
t.unionTypeAnnotation(types);

See also t.isUnionTypeAnnotation(node, opts) and t.assertUnionTypeAnnotation(node, opts).

AST Node UnionTypeAnnotation shape:

  • types: Array<FlowType> (required)

Aliases: Flow, FlowType


updateExpression

JavaScript
t.updateExpression(operator, argument, prefix);

See also t.isUpdateExpression(node, opts) and t.assertUpdateExpression(node, opts).

AST Node UpdateExpression shape:

  • operator: "++" | "--" (required)
  • argument: Expression (required)
  • prefix: boolean (default: false)

Aliases: Standardized, Expression


v8IntrinsicIdentifier

JavaScript
t.v8IntrinsicIdentifier(name);

See also t.isV8IntrinsicIdentifier(node, opts) and t.assertV8IntrinsicIdentifier(node, opts).

AST Node V8IntrinsicIdentifier shape:

  • name: string (required)

Aliases: Miscellaneous


variableDeclaration

JavaScript
t.variableDeclaration(kind, declarations);
History
VersionChanges
v7.20.0kind can be "using".

See also t.isVariableDeclaration(node, opts) and t.assertVariableDeclaration(node, opts).

AST Node VariableDeclaration shape:

  • kind: "var" | "let" | "const" | "using" | "await using" (required)
  • declarations: Array<VariableDeclarator> (required)
  • declare: boolean (default: null, excluded from builder function)

Aliases: Standardized, Statement, Declaration


variableDeclarator

JavaScript
t.variableDeclarator(id, init);

See also t.isVariableDeclarator(node, opts) and t.assertVariableDeclarator(node, opts).

AST Node VariableDeclarator shape:

  • id: LVal (required)
  • init: Expression (default: null)
  • definite: boolean (default: null, excluded from builder function)

Aliases: Standardized


variance

JavaScript
t.variance(kind);

See also t.isVariance(node, opts) and t.assertVariance(node, opts).

AST Node Variance shape:

  • kind: "minus" | "plus" (required)

Aliases: Flow


voidTypeAnnotation

JavaScript
t.voidTypeAnnotation();

See also t.isVoidTypeAnnotation(node, opts) and t.assertVoidTypeAnnotation(node, opts).

Aliases: Flow, FlowType, FlowBaseAnnotation


whileStatement

JavaScript
t.whileStatement(test, body);

See also t.isWhileStatement(node, opts) and t.assertWhileStatement(node, opts).

AST Node WhileStatement shape:

  • test: Expression (required)
  • body: Statement (required)

Aliases: Standardized, Statement, BlockParent, Loop, While, Scopable


withStatement

JavaScript
t.withStatement(object, body);

See also t.isWithStatement(node, opts) and t.assertWithStatement(node, opts).

AST Node WithStatement shape:

  • object: Expression (required)
  • body: Statement (required)

Aliases: Standardized, Statement


yieldExpression

JavaScript
t.yieldExpression(argument, delegate);

See also t.isYieldExpression(node, opts) and t.assertYieldExpression(node, opts).

AST Node YieldExpression shape:

  • argument: Expression (default: null)
  • delegate: boolean (default: false)

Aliases: Standardized, Expression, Terminatorless


Aliases

Accessor

Deprecated. Will be removed in Babel 8.

JavaScript
t.isAccessor(node);

Covered nodes:

Binary

A cover of BinaryExpression and LogicalExpression, which share the same AST shape.

JavaScript
t.isBinary(node);

Covered nodes:

Block

Deprecated. Will be removed in Babel 8.

JavaScript
t.isBlock(node);

Covered nodes:

BlockParent

A cover of AST nodes that start an execution context with new LexicalEnvironment. In other words, they define the scope of let and const declarations.

JavaScript
t.isBlockParent(node);

Covered nodes:

Class

A cover of ClassExpression and ClassDeclaration, which share the same AST shape.

JavaScript
t.isClass(node);

Covered nodes:

CompletionStatement

A statement that indicates the completion records. In other words, they define the control flow of the program, such as when should a loop break or an action throws critical errors.

JavaScript
t.isCompletionStatement(node);

Covered nodes:

Conditional

A cover of ConditionalExpression and IfStatement, which share the same AST shape.

JavaScript
t.isConditional(node);

Covered nodes:

Declaration

A cover of any Declarations.

JavaScript
t.isDeclaration(node);

Covered nodes:

EnumBody

A cover of Flow enum bodies.

JavaScript
t.isEnumBody(node);

Covered nodes:

EnumMember

A cover of Flow enum members.

JavaScript
t.isEnumMember(node);

Covered nodes:

ExportDeclaration

A cover of any ExportDeclarations.

JavaScript
t.isExportDeclaration(node);

Covered nodes:

Expression

A cover of any Expressions.

JavaScript
t.isExpression(node);

Covered nodes:

ExpressionWrapper

A wrapper of expression that does not have runtime semantics.

JavaScript
t.isExpressionWrapper(node);

Covered nodes:

Flow

A cover of AST nodes defined for Flow.

JavaScript
t.isFlow(node);

Covered nodes:

FlowBaseAnnotation

A cover of primary Flow type annotations.

JavaScript
t.isFlowBaseAnnotation(node);

Covered nodes:

FlowDeclaration

A cover of Flow declarations.

JavaScript
t.isFlowDeclaration(node);

Covered nodes:

FlowPredicate

A cover of Flow predicates.

JavaScript
t.isFlowPredicate(node);

Covered nodes:

FlowType

A cover of Flow type annotations.

JavaScript
t.isFlowType(node);

Covered nodes:

For

A cover of ForStatements and ForXStatements.

JavaScript
t.isFor(node);

Covered nodes:

ForXStatement

A cover of ForInStatements and ForOfStatements.

JavaScript
t.isForXStatement(node);

Covered nodes:

Function

A cover of functions and methods, the must have body and params. Note: Function is different to FunctionParent. For example, a StaticBlock is a FunctionParent but not Function.

JavaScript
t.isFunction(node);

Covered nodes:

FunctionParent

A cover of AST nodes that start an execution context with new VariableEnvironment. In other words, they define the scope of var declarations. FunctionParent did not include Program since Babel 7.

JavaScript
t.isFunctionParent(node);

Covered nodes:

Immutable

A cover of immutable objects and JSX elements. An object is immutable if no other properties can be defined once created.

JavaScript
t.isImmutable(node);

Covered nodes:

ImportOrExportDeclaration

History
VersionChanges
v7.21.0Introduced

A cover of ImportDeclaration and ExportDeclaration.

JavaScript
t.isImportOrExportDeclaration(node);

Covered nodes:

JSX

A cover of AST nodes defined for JSX.

JavaScript
t.isJSX(node);

Covered nodes:

LVal

A cover of left hand side expressions used in the left of assignment expressions and ForXStatements.

JavaScript
t.isLVal(node);

Covered nodes:

Literal

A cover of Literals, Regular Expression Literals and Template Literals.

JavaScript
t.isLiteral(node);

Covered nodes:

Loop

A cover of loop statements.

JavaScript
t.isLoop(node);

Covered nodes:

Method

A cover of object methods and class methods.

JavaScript
t.isMethod(node);

Covered nodes:

Miscellaneous

A cover of non-standard AST types that are sometimes useful for development.

JavaScript
t.isMiscellaneous(node);

Covered nodes:

ModuleDeclaration

History
VersionChanges
v7.21.0Deprecated
caution

Deprecated, use ImportOrExportDeclaration instead. Check out PR #15266 for migration notes.

JavaScript
t.isModuleDeclaration(node);

Covered nodes:

ModuleSpecifier

A cover of import and export specifiers. Note: It is not the ModuleSpecifier defined in the spec.

JavaScript
t.isModuleSpecifier(node);

Covered nodes:

ObjectMember

A cover of members in an object literal.

JavaScript
t.isObjectMember(node);

Covered nodes:

Pattern

A cover of BindingPattern except Identifiers.

JavaScript
t.isPattern(node);

Covered nodes:

PatternLike

A cover of BindingPatterns.

JavaScript
t.isPatternLike(node);

Covered nodes:

Private

A cover of private class elements and private identifiers.

JavaScript
t.isPrivate(node);

Covered nodes:

Property

A cover of object properties and class properties.

JavaScript
t.isProperty(node);

Covered nodes:

Pureish

A cover of AST nodes which do not have side-effects. In other words, there is no observable behaviour changes if they are evaluated more than once.

JavaScript
t.isPureish(node);

Covered nodes:

Scopable

A cover of FunctionParent and BlockParent.

JavaScript
t.isScopable(node);

Covered nodes:

Standardized

A cover of AST nodes which are part of an official ECMAScript specification.

JavaScript
t.isStandardized(node);

Covered nodes:

Statement

A cover of any Statements.

JavaScript
t.isStatement(node);

Covered nodes:

TSBaseType

A cover of primary TypeScript type annotations.

JavaScript
t.isTSBaseType(node);

Covered nodes:

TSEntityName

A cover of ts entities.

JavaScript
t.isTSEntityName(node);

Covered nodes:

TSType

A cover of TypeScript type annotations.

JavaScript
t.isTSType(node);

Covered nodes:

TSTypeElement

A cover of TypeScript type declarations.

JavaScript
t.isTSTypeElement(node);

Covered nodes:

Terminatorless

A cover of AST nodes whose semantic will change when a line terminator is inserted between the operator and the operand.

JavaScript
t.isTerminatorless(node);

Covered nodes:

TypeScript

A cover of AST nodes defined for TypeScript.

JavaScript
t.isTypeScript(node);

Covered nodes:

UnaryLike

A cover of UnaryExpression and SpreadElement.

JavaScript
t.isUnaryLike(node);

Covered nodes:

UserWhitespacable

Deprecated. Will be removed in Babel 8.

JavaScript
t.isUserWhitespacable(node);

Covered nodes:

While

A cover of DoWhileStatement and WhileStatement, which share the same AST shape.

JavaScript
t.isWhile(node);

Covered nodes: