@types/babel-traverse - npm Package Compare versions

Comparing version 6.7.8-alpha to 6.7.9-alpha

1680

index.d.ts

		@@ -8,960 +8,960 @@ // Type definitions for babel-traverse v6.7

		declare module "babel-traverse" {
		import * as t from 'babel-types';
		type Node = t.Node;

		export default function traverse(parent: Node \| Node[], opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath<Node>): void;
		import * as t from 'babel-types';
		type Node = t.Node;

		export interface TraverseOptions extends Visitor {
		scope?: Scope;
		noScope?: boolean;
		}
		export default function traverse(parent: Node \| Node[], opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath<Node>): void;

		export class Scope {
		constructor(path: NodePath<Node>, parentScope?: Scope);
		path: NodePath<Node>;
		block: Node;
		parentBlock: Node;
		parent: Scope;
		hub: Hub;
		bindings: { [name: string]: Binding; };
		export interface TraverseOptions extends Visitor {
		scope?: Scope;
		noScope?: boolean;
		}

		/** Traverse node with current scope and path. */
		traverse(node: Node \| Node[], opts?: TraverseOptions, state?: any): void;
		export class Scope {
		constructor(path: NodePath<Node>, parentScope?: Scope);
		path: NodePath<Node>;
		block: Node;
		parentBlock: Node;
		parent: Scope;
		hub: Hub;
		bindings: { [name: string]: Binding; };

		/** Generate a unique identifier and add it to the current scope. */
		generateDeclaredUidIdentifier(name?: string): t.Identifier;
		/** Traverse node with current scope and path. */
		traverse(node: Node \| Node[], opts?: TraverseOptions, state?: any): void;

		/** Generate a unique identifier. */
		generateUidIdentifier(name?: string): t.Identifier;
		/** Generate a unique identifier and add it to the current scope. */
		generateDeclaredUidIdentifier(name?: string): t.Identifier;

		/** Generate a unique `_id1` binding. */
		generateUid(name?: string): string;
		/** Generate a unique identifier. */
		generateUidIdentifier(name?: string): t.Identifier;

		/** Generate a unique identifier based on a node. */
		generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): t.Identifier;
		/** Generate a unique `_id1` binding. */
		generateUid(name?: string): string;

		/**
		* Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
		* evaluating it wont result in potentially arbitrary code from being ran. The following are
		* whitelisted and determined not to cause side effects:
		*
		* - `this` expressions
		* - `super` expressions
		* - Bound identifiers
		*/
		isStatic(node: Node): boolean;
		/** Generate a unique identifier based on a node. */
		generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): t.Identifier;

		/** Possibly generate a memoised identifier if it is not static and has consequences. */
		maybeGenerateMemoised(node: Node, dontPush?: boolean): t.Identifier;
		/**
		* Determine whether evaluating the specific input `node` is a consequenceless reference. ie.
		* evaluating it wont result in potentially arbitrary code from being ran. The following are
		* whitelisted and determined not to cause side effects:
		*
		* - `this` expressions
		* - `super` expressions
		* - Bound identifiers
		*/
		isStatic(node: Node): boolean;

		checkBlockScopedCollisions(local: Node, kind: string, name: string, id: Object): void;
		/** Possibly generate a memoised identifier if it is not static and has consequences. */
		maybeGenerateMemoised(node: Node, dontPush?: boolean): t.Identifier;

		rename(oldName: string, newName?: string, block?: Node): void;
		checkBlockScopedCollisions(local: Node, kind: string, name: string, id: Object): void;

		dump(): void;
		rename(oldName: string, newName?: string, block?: Node): void;

		toArray(node: Node, i?: number): Node;
		dump(): void;

		registerDeclaration(path: NodePath<Node>): void;
		toArray(node: Node, i?: number): Node;

		buildUndefinedNode(): Node;
		registerDeclaration(path: NodePath<Node>): void;

		registerConstantViolation(path: NodePath<Node>): void;
		buildUndefinedNode(): Node;

		registerBinding(kind: string, path: NodePath<Node>, bindingPath?: NodePath<Node>): void;
		registerConstantViolation(path: NodePath<Node>): void;

		addGlobal(node: Node): void;
		registerBinding(kind: string, path: NodePath<Node>, bindingPath?: NodePath<Node>): void;

		hasUid(name: string): boolean;
		addGlobal(node: Node): void;

		hasGlobal(name: string): boolean;
		hasUid(name: string): boolean;

		hasReference(name: string): boolean;
		hasGlobal(name: string): boolean;

		isPure(node: Node, constantsOnly?: boolean): boolean;
		hasReference(name: string): boolean;

		setData(key: string, val: any): any;
		isPure(node: Node, constantsOnly?: boolean): boolean;

		getData(key: string): any;
		setData(key: string, val: any): any;

		removeData(key: string): void;
		getData(key: string): any;

		push(opts: any): void;
		removeData(key: string): void;

		getProgramParent(): Scope;
		push(opts: any): void;

		getFunctionParent(): Scope;
		getProgramParent(): Scope;

		getBlockParent(): Scope;
		getFunctionParent(): Scope;

		/ Walks the scope tree and gathers all** bindings. */
		getAllBindings(...kinds: string[]): Object;
		getBlockParent(): Scope;

		bindingIdentifierEquals(name: string, node: Node): boolean;
		/ Walks the scope tree and gathers all** bindings. */
		getAllBindings(...kinds: string[]): Object;

		getBinding(name: string): Binding;
		bindingIdentifierEquals(name: string, node: Node): boolean;

		getOwnBinding(name: string): Binding;
		getBinding(name: string): Binding;

		getBindingIdentifier(name: string): t.Identifier;
		getOwnBinding(name: string): Binding;

		getOwnBindingIdentifier(name: string): t.Identifier;
		getBindingIdentifier(name: string): t.Identifier;

		hasOwnBinding(name: string): boolean;
		getOwnBindingIdentifier(name: string): t.Identifier;

		hasBinding(name: string, noGlobals?: boolean): boolean;
		hasOwnBinding(name: string): boolean;

		parentHasBinding(name: string, noGlobals?: boolean): boolean;
		hasBinding(name: string, noGlobals?: boolean): boolean;

		/** Move a binding of `name` to another `scope`. */
		moveBindingTo(name: string, scope: Scope): void;
		parentHasBinding(name: string, noGlobals?: boolean): boolean;

		removeOwnBinding(name: string): void;
		/** Move a binding of `name` to another `scope`. */
		moveBindingTo(name: string, scope: Scope): void;

		removeBinding(name: string): void;
		}
		removeOwnBinding(name: string): void;

		export class Binding {
		constructor(opts: { existing: Binding; identifier: t.Identifier; scope: Scope; path: NodePath<Node>; kind: 'var' \| 'let' \| 'const'; });
		identifier: t.Identifier;
		scope: Scope;
		path: NodePath<Node>;
		kind: 'var' \| 'let' \| 'const';
		referenced: boolean;
		references: number;
		referencePaths: NodePath<Node>[];
		constant: boolean;
		constantViolations: NodePath<Node>[];
		}
		removeBinding(name: string): void;
		}

		export interface Visitor extends VisitNodeObject<Node> {
		ArrayExpression?: VisitNode<t.ArrayExpression>;
		AssignmentExpression?: VisitNode<t.AssignmentExpression>;
		LVal?: VisitNode<t.LVal>;
		Expression?: VisitNode<t.Expression>;
		BinaryExpression?: VisitNode<t.BinaryExpression>;
		Directive?: VisitNode<t.Directive>;
		DirectiveLiteral?: VisitNode<t.DirectiveLiteral>;
		BlockStatement?: VisitNode<t.BlockStatement>;
		BreakStatement?: VisitNode<t.BreakStatement>;
		Identifier?: VisitNode<t.Identifier>;
		CallExpression?: VisitNode<t.CallExpression>;
		CatchClause?: VisitNode<t.CatchClause>;
		ConditionalExpression?: VisitNode<t.ConditionalExpression>;
		ContinueStatement?: VisitNode<t.ContinueStatement>;
		DebuggerStatement?: VisitNode<t.DebuggerStatement>;
		DoWhileStatement?: VisitNode<t.DoWhileStatement>;
		Statement?: VisitNode<t.Statement>;
		EmptyStatement?: VisitNode<t.EmptyStatement>;
		ExpressionStatement?: VisitNode<t.ExpressionStatement>;
		File?: VisitNode<t.File>;
		Program?: VisitNode<t.Program>;
		ForInStatement?: VisitNode<t.ForInStatement>;
		VariableDeclaration?: VisitNode<t.VariableDeclaration>;
		ForStatement?: VisitNode<t.ForStatement>;
		FunctionDeclaration?: VisitNode<t.FunctionDeclaration>;
		FunctionExpression?: VisitNode<t.FunctionExpression>;
		IfStatement?: VisitNode<t.IfStatement>;
		LabeledStatement?: VisitNode<t.LabeledStatement>;
		StringLiteral?: VisitNode<t.StringLiteral>;
		NumericLiteral?: VisitNode<t.NumericLiteral>;
		NullLiteral?: VisitNode<t.NullLiteral>;
		BooleanLiteral?: VisitNode<t.BooleanLiteral>;
		RegExpLiteral?: VisitNode<t.RegExpLiteral>;
		LogicalExpression?: VisitNode<t.LogicalExpression>;
		MemberExpression?: VisitNode<t.MemberExpression>;
		NewExpression?: VisitNode<t.NewExpression>;
		ObjectExpression?: VisitNode<t.ObjectExpression>;
		ObjectMethod?: VisitNode<t.ObjectMethod>;
		ObjectProperty?: VisitNode<t.ObjectProperty>;
		RestElement?: VisitNode<t.RestElement>;
		ReturnStatement?: VisitNode<t.ReturnStatement>;
		SequenceExpression?: VisitNode<t.SequenceExpression>;
		SwitchCase?: VisitNode<t.SwitchCase>;
		SwitchStatement?: VisitNode<t.SwitchStatement>;
		ThisExpression?: VisitNode<t.ThisExpression>;
		ThrowStatement?: VisitNode<t.ThrowStatement>;
		TryStatement?: VisitNode<t.TryStatement>;
		UnaryExpression?: VisitNode<t.UnaryExpression>;
		UpdateExpression?: VisitNode<t.UpdateExpression>;
		VariableDeclarator?: VisitNode<t.VariableDeclarator>;
		WhileStatement?: VisitNode<t.WhileStatement>;
		WithStatement?: VisitNode<t.WithStatement>;
		AssignmentPattern?: VisitNode<t.AssignmentPattern>;
		ArrayPattern?: VisitNode<t.ArrayPattern>;
		ArrowFunctionExpression?: VisitNode<t.ArrowFunctionExpression>;
		ClassBody?: VisitNode<t.ClassBody>;
		ClassDeclaration?: VisitNode<t.ClassDeclaration>;
		ClassExpression?: VisitNode<t.ClassExpression>;
		ExportAllDeclaration?: VisitNode<t.ExportAllDeclaration>;
		ExportDefaultDeclaration?: VisitNode<t.ExportDefaultDeclaration>;
		ExportNamedDeclaration?: VisitNode<t.ExportNamedDeclaration>;
		Declaration?: VisitNode<t.Declaration>;
		ExportSpecifier?: VisitNode<t.ExportSpecifier>;
		ForOfStatement?: VisitNode<t.ForOfStatement>;
		ImportDeclaration?: VisitNode<t.ImportDeclaration>;
		ImportDefaultSpecifier?: VisitNode<t.ImportDefaultSpecifier>;
		ImportNamespaceSpecifier?: VisitNode<t.ImportNamespaceSpecifier>;
		ImportSpecifier?: VisitNode<t.ImportSpecifier>;
		MetaProperty?: VisitNode<t.MetaProperty>;
		ClassMethod?: VisitNode<t.ClassMethod>;
		ObjectPattern?: VisitNode<t.ObjectPattern>;
		SpreadElement?: VisitNode<t.SpreadElement>;
		Super?: VisitNode<t.Super>;
		TaggedTemplateExpression?: VisitNode<t.TaggedTemplateExpression>;
		TemplateLiteral?: VisitNode<t.TemplateLiteral>;
		TemplateElement?: VisitNode<t.TemplateElement>;
		YieldExpression?: VisitNode<t.YieldExpression>;
		AnyTypeAnnotation?: VisitNode<t.AnyTypeAnnotation>;
		ArrayTypeAnnotation?: VisitNode<t.ArrayTypeAnnotation>;
		BooleanTypeAnnotation?: VisitNode<t.BooleanTypeAnnotation>;
		BooleanLiteralTypeAnnotation?: VisitNode<t.BooleanLiteralTypeAnnotation>;
		NullLiteralTypeAnnotation?: VisitNode<t.NullLiteralTypeAnnotation>;
		ClassImplements?: VisitNode<t.ClassImplements>;
		ClassProperty?: VisitNode<t.ClassProperty>;
		DeclareClass?: VisitNode<t.DeclareClass>;
		DeclareFunction?: VisitNode<t.DeclareFunction>;
		DeclareInterface?: VisitNode<t.DeclareInterface>;
		DeclareModule?: VisitNode<t.DeclareModule>;
		DeclareTypeAlias?: VisitNode<t.DeclareTypeAlias>;
		DeclareVariable?: VisitNode<t.DeclareVariable>;
		ExistentialTypeParam?: VisitNode<t.ExistentialTypeParam>;
		FunctionTypeAnnotation?: VisitNode<t.FunctionTypeAnnotation>;
		FunctionTypeParam?: VisitNode<t.FunctionTypeParam>;
		GenericTypeAnnotation?: VisitNode<t.GenericTypeAnnotation>;
		InterfaceExtends?: VisitNode<t.InterfaceExtends>;
		InterfaceDeclaration?: VisitNode<t.InterfaceDeclaration>;
		IntersectionTypeAnnotation?: VisitNode<t.IntersectionTypeAnnotation>;
		MixedTypeAnnotation?: VisitNode<t.MixedTypeAnnotation>;
		NullableTypeAnnotation?: VisitNode<t.NullableTypeAnnotation>;
		NumericLiteralTypeAnnotation?: VisitNode<t.NumericLiteralTypeAnnotation>;
		NumberTypeAnnotation?: VisitNode<t.NumberTypeAnnotation>;
		StringLiteralTypeAnnotation?: VisitNode<t.StringLiteralTypeAnnotation>;
		StringTypeAnnotation?: VisitNode<t.StringTypeAnnotation>;
		ThisTypeAnnotation?: VisitNode<t.ThisTypeAnnotation>;
		TupleTypeAnnotation?: VisitNode<t.TupleTypeAnnotation>;
		TypeofTypeAnnotation?: VisitNode<t.TypeofTypeAnnotation>;
		TypeAlias?: VisitNode<t.TypeAlias>;
		TypeAnnotation?: VisitNode<t.TypeAnnotation>;
		TypeCastExpression?: VisitNode<t.TypeCastExpression>;
		TypeParameterDeclaration?: VisitNode<t.TypeParameterDeclaration>;
		TypeParameterInstantiation?: VisitNode<t.TypeParameterInstantiation>;
		ObjectTypeAnnotation?: VisitNode<t.ObjectTypeAnnotation>;
		ObjectTypeCallProperty?: VisitNode<t.ObjectTypeCallProperty>;
		ObjectTypeIndexer?: VisitNode<t.ObjectTypeIndexer>;
		ObjectTypeProperty?: VisitNode<t.ObjectTypeProperty>;
		QualifiedTypeIdentifier?: VisitNode<t.QualifiedTypeIdentifier>;
		UnionTypeAnnotation?: VisitNode<t.UnionTypeAnnotation>;
		VoidTypeAnnotation?: VisitNode<t.VoidTypeAnnotation>;
		JSXAttribute?: VisitNode<t.JSXAttribute>;
		JSXIdentifier?: VisitNode<t.JSXIdentifier>;
		JSXNamespacedName?: VisitNode<t.JSXNamespacedName>;
		JSXElement?: VisitNode<t.JSXElement>;
		JSXExpressionContainer?: VisitNode<t.JSXExpressionContainer>;
		JSXClosingElement?: VisitNode<t.JSXClosingElement>;
		JSXMemberExpression?: VisitNode<t.JSXMemberExpression>;
		JSXOpeningElement?: VisitNode<t.JSXOpeningElement>;
		JSXEmptyExpression?: VisitNode<t.JSXEmptyExpression>;
		JSXSpreadAttribute?: VisitNode<t.JSXSpreadAttribute>;
		JSXText?: VisitNode<t.JSXText>;
		Noop?: VisitNode<t.Noop>;
		ParenthesizedExpression?: VisitNode<t.ParenthesizedExpression>;
		AwaitExpression?: VisitNode<t.AwaitExpression>;
		BindExpression?: VisitNode<t.BindExpression>;
		Decorator?: VisitNode<t.Decorator>;
		DoExpression?: VisitNode<t.DoExpression>;
		ExportDefaultSpecifier?: VisitNode<t.ExportDefaultSpecifier>;
		ExportNamespaceSpecifier?: VisitNode<t.ExportNamespaceSpecifier>;
		RestProperty?: VisitNode<t.RestProperty>;
		SpreadProperty?: VisitNode<t.SpreadProperty>;
		Binary?: VisitNode<t.Binary>;
		Scopable?: VisitNode<t.Scopable>;
		BlockParent?: VisitNode<t.BlockParent>;
		Block?: VisitNode<t.Block>;
		Terminatorless?: VisitNode<t.Terminatorless>;
		CompletionStatement?: VisitNode<t.CompletionStatement>;
		Conditional?: VisitNode<t.Conditional>;
		Loop?: VisitNode<t.Loop>;
		While?: VisitNode<t.While>;
		ExpressionWrapper?: VisitNode<t.ExpressionWrapper>;
		For?: VisitNode<t.For>;
		ForXStatement?: VisitNode<t.ForXStatement>;
		Function?: VisitNode<t.Function>;
		FunctionParent?: VisitNode<t.FunctionParent>;
		Pureish?: VisitNode<t.Pureish>;
		Literal?: VisitNode<t.Literal>;
		Immutable?: VisitNode<t.Immutable>;
		UserWhitespacable?: VisitNode<t.UserWhitespacable>;
		Method?: VisitNode<t.Method>;
		ObjectMember?: VisitNode<t.ObjectMember>;
		Property?: VisitNode<t.Property>;
		UnaryLike?: VisitNode<t.UnaryLike>;
		Pattern?: VisitNode<t.Pattern>;
		Class?: VisitNode<t.Class>;
		ModuleDeclaration?: VisitNode<t.ModuleDeclaration>;
		ExportDeclaration?: VisitNode<t.ExportDeclaration>;
		ModuleSpecifier?: VisitNode<t.ModuleSpecifier>;
		Flow?: VisitNode<t.Flow>;
		FlowBaseAnnotation?: VisitNode<t.FlowBaseAnnotation>;
		FlowDeclaration?: VisitNode<t.FlowDeclaration>;
		JSX?: VisitNode<t.JSX>;
		}
		export class Binding {
		constructor(opts: { existing: Binding; identifier: t.Identifier; scope: Scope; path: NodePath<Node>; kind: 'var' \| 'let' \| 'const'; });
		identifier: t.Identifier;
		scope: Scope;
		path: NodePath<Node>;
		kind: 'var' \| 'let' \| 'const';
		referenced: boolean;
		references: number;
		referencePaths: NodePath<Node>[];
		constant: boolean;
		constantViolations: NodePath<Node>[];
		}

		export type VisitNode<T> = VisitNodeFunction<T> \| VisitNodeObject<T>;
		export interface Visitor extends VisitNodeObject<Node> {
		ArrayExpression?: VisitNode<t.ArrayExpression>;
		AssignmentExpression?: VisitNode<t.AssignmentExpression>;
		LVal?: VisitNode<t.LVal>;
		Expression?: VisitNode<t.Expression>;
		BinaryExpression?: VisitNode<t.BinaryExpression>;
		Directive?: VisitNode<t.Directive>;
		DirectiveLiteral?: VisitNode<t.DirectiveLiteral>;
		BlockStatement?: VisitNode<t.BlockStatement>;
		BreakStatement?: VisitNode<t.BreakStatement>;
		Identifier?: VisitNode<t.Identifier>;
		CallExpression?: VisitNode<t.CallExpression>;
		CatchClause?: VisitNode<t.CatchClause>;
		ConditionalExpression?: VisitNode<t.ConditionalExpression>;
		ContinueStatement?: VisitNode<t.ContinueStatement>;
		DebuggerStatement?: VisitNode<t.DebuggerStatement>;
		DoWhileStatement?: VisitNode<t.DoWhileStatement>;
		Statement?: VisitNode<t.Statement>;
		EmptyStatement?: VisitNode<t.EmptyStatement>;
		ExpressionStatement?: VisitNode<t.ExpressionStatement>;
		File?: VisitNode<t.File>;
		Program?: VisitNode<t.Program>;
		ForInStatement?: VisitNode<t.ForInStatement>;
		VariableDeclaration?: VisitNode<t.VariableDeclaration>;
		ForStatement?: VisitNode<t.ForStatement>;
		FunctionDeclaration?: VisitNode<t.FunctionDeclaration>;
		FunctionExpression?: VisitNode<t.FunctionExpression>;
		IfStatement?: VisitNode<t.IfStatement>;
		LabeledStatement?: VisitNode<t.LabeledStatement>;
		StringLiteral?: VisitNode<t.StringLiteral>;
		NumericLiteral?: VisitNode<t.NumericLiteral>;
		NullLiteral?: VisitNode<t.NullLiteral>;
		BooleanLiteral?: VisitNode<t.BooleanLiteral>;
		RegExpLiteral?: VisitNode<t.RegExpLiteral>;
		LogicalExpression?: VisitNode<t.LogicalExpression>;
		MemberExpression?: VisitNode<t.MemberExpression>;
		NewExpression?: VisitNode<t.NewExpression>;
		ObjectExpression?: VisitNode<t.ObjectExpression>;
		ObjectMethod?: VisitNode<t.ObjectMethod>;
		ObjectProperty?: VisitNode<t.ObjectProperty>;
		RestElement?: VisitNode<t.RestElement>;
		ReturnStatement?: VisitNode<t.ReturnStatement>;
		SequenceExpression?: VisitNode<t.SequenceExpression>;
		SwitchCase?: VisitNode<t.SwitchCase>;
		SwitchStatement?: VisitNode<t.SwitchStatement>;
		ThisExpression?: VisitNode<t.ThisExpression>;
		ThrowStatement?: VisitNode<t.ThrowStatement>;
		TryStatement?: VisitNode<t.TryStatement>;
		UnaryExpression?: VisitNode<t.UnaryExpression>;
		UpdateExpression?: VisitNode<t.UpdateExpression>;
		VariableDeclarator?: VisitNode<t.VariableDeclarator>;
		WhileStatement?: VisitNode<t.WhileStatement>;
		WithStatement?: VisitNode<t.WithStatement>;
		AssignmentPattern?: VisitNode<t.AssignmentPattern>;
		ArrayPattern?: VisitNode<t.ArrayPattern>;
		ArrowFunctionExpression?: VisitNode<t.ArrowFunctionExpression>;
		ClassBody?: VisitNode<t.ClassBody>;
		ClassDeclaration?: VisitNode<t.ClassDeclaration>;
		ClassExpression?: VisitNode<t.ClassExpression>;
		ExportAllDeclaration?: VisitNode<t.ExportAllDeclaration>;
		ExportDefaultDeclaration?: VisitNode<t.ExportDefaultDeclaration>;
		ExportNamedDeclaration?: VisitNode<t.ExportNamedDeclaration>;
		Declaration?: VisitNode<t.Declaration>;
		ExportSpecifier?: VisitNode<t.ExportSpecifier>;
		ForOfStatement?: VisitNode<t.ForOfStatement>;
		ImportDeclaration?: VisitNode<t.ImportDeclaration>;
		ImportDefaultSpecifier?: VisitNode<t.ImportDefaultSpecifier>;
		ImportNamespaceSpecifier?: VisitNode<t.ImportNamespaceSpecifier>;
		ImportSpecifier?: VisitNode<t.ImportSpecifier>;
		MetaProperty?: VisitNode<t.MetaProperty>;
		ClassMethod?: VisitNode<t.ClassMethod>;
		ObjectPattern?: VisitNode<t.ObjectPattern>;
		SpreadElement?: VisitNode<t.SpreadElement>;
		Super?: VisitNode<t.Super>;
		TaggedTemplateExpression?: VisitNode<t.TaggedTemplateExpression>;
		TemplateLiteral?: VisitNode<t.TemplateLiteral>;
		TemplateElement?: VisitNode<t.TemplateElement>;
		YieldExpression?: VisitNode<t.YieldExpression>;
		AnyTypeAnnotation?: VisitNode<t.AnyTypeAnnotation>;
		ArrayTypeAnnotation?: VisitNode<t.ArrayTypeAnnotation>;
		BooleanTypeAnnotation?: VisitNode<t.BooleanTypeAnnotation>;
		BooleanLiteralTypeAnnotation?: VisitNode<t.BooleanLiteralTypeAnnotation>;
		NullLiteralTypeAnnotation?: VisitNode<t.NullLiteralTypeAnnotation>;
		ClassImplements?: VisitNode<t.ClassImplements>;
		ClassProperty?: VisitNode<t.ClassProperty>;
		DeclareClass?: VisitNode<t.DeclareClass>;
		DeclareFunction?: VisitNode<t.DeclareFunction>;
		DeclareInterface?: VisitNode<t.DeclareInterface>;
		DeclareModule?: VisitNode<t.DeclareModule>;
		DeclareTypeAlias?: VisitNode<t.DeclareTypeAlias>;
		DeclareVariable?: VisitNode<t.DeclareVariable>;
		ExistentialTypeParam?: VisitNode<t.ExistentialTypeParam>;
		FunctionTypeAnnotation?: VisitNode<t.FunctionTypeAnnotation>;
		FunctionTypeParam?: VisitNode<t.FunctionTypeParam>;
		GenericTypeAnnotation?: VisitNode<t.GenericTypeAnnotation>;
		InterfaceExtends?: VisitNode<t.InterfaceExtends>;
		InterfaceDeclaration?: VisitNode<t.InterfaceDeclaration>;
		IntersectionTypeAnnotation?: VisitNode<t.IntersectionTypeAnnotation>;
		MixedTypeAnnotation?: VisitNode<t.MixedTypeAnnotation>;
		NullableTypeAnnotation?: VisitNode<t.NullableTypeAnnotation>;
		NumericLiteralTypeAnnotation?: VisitNode<t.NumericLiteralTypeAnnotation>;
		NumberTypeAnnotation?: VisitNode<t.NumberTypeAnnotation>;
		StringLiteralTypeAnnotation?: VisitNode<t.StringLiteralTypeAnnotation>;
		StringTypeAnnotation?: VisitNode<t.StringTypeAnnotation>;
		ThisTypeAnnotation?: VisitNode<t.ThisTypeAnnotation>;
		TupleTypeAnnotation?: VisitNode<t.TupleTypeAnnotation>;
		TypeofTypeAnnotation?: VisitNode<t.TypeofTypeAnnotation>;
		TypeAlias?: VisitNode<t.TypeAlias>;
		TypeAnnotation?: VisitNode<t.TypeAnnotation>;
		TypeCastExpression?: VisitNode<t.TypeCastExpression>;
		TypeParameterDeclaration?: VisitNode<t.TypeParameterDeclaration>;
		TypeParameterInstantiation?: VisitNode<t.TypeParameterInstantiation>;
		ObjectTypeAnnotation?: VisitNode<t.ObjectTypeAnnotation>;
		ObjectTypeCallProperty?: VisitNode<t.ObjectTypeCallProperty>;
		ObjectTypeIndexer?: VisitNode<t.ObjectTypeIndexer>;
		ObjectTypeProperty?: VisitNode<t.ObjectTypeProperty>;
		QualifiedTypeIdentifier?: VisitNode<t.QualifiedTypeIdentifier>;
		UnionTypeAnnotation?: VisitNode<t.UnionTypeAnnotation>;
		VoidTypeAnnotation?: VisitNode<t.VoidTypeAnnotation>;
		JSXAttribute?: VisitNode<t.JSXAttribute>;
		JSXIdentifier?: VisitNode<t.JSXIdentifier>;
		JSXNamespacedName?: VisitNode<t.JSXNamespacedName>;
		JSXElement?: VisitNode<t.JSXElement>;
		JSXExpressionContainer?: VisitNode<t.JSXExpressionContainer>;
		JSXClosingElement?: VisitNode<t.JSXClosingElement>;
		JSXMemberExpression?: VisitNode<t.JSXMemberExpression>;
		JSXOpeningElement?: VisitNode<t.JSXOpeningElement>;
		JSXEmptyExpression?: VisitNode<t.JSXEmptyExpression>;
		JSXSpreadAttribute?: VisitNode<t.JSXSpreadAttribute>;
		JSXText?: VisitNode<t.JSXText>;
		Noop?: VisitNode<t.Noop>;
		ParenthesizedExpression?: VisitNode<t.ParenthesizedExpression>;
		AwaitExpression?: VisitNode<t.AwaitExpression>;
		BindExpression?: VisitNode<t.BindExpression>;
		Decorator?: VisitNode<t.Decorator>;
		DoExpression?: VisitNode<t.DoExpression>;
		ExportDefaultSpecifier?: VisitNode<t.ExportDefaultSpecifier>;
		ExportNamespaceSpecifier?: VisitNode<t.ExportNamespaceSpecifier>;
		RestProperty?: VisitNode<t.RestProperty>;
		SpreadProperty?: VisitNode<t.SpreadProperty>;
		Binary?: VisitNode<t.Binary>;
		Scopable?: VisitNode<t.Scopable>;
		BlockParent?: VisitNode<t.BlockParent>;
		Block?: VisitNode<t.Block>;
		Terminatorless?: VisitNode<t.Terminatorless>;
		CompletionStatement?: VisitNode<t.CompletionStatement>;
		Conditional?: VisitNode<t.Conditional>;
		Loop?: VisitNode<t.Loop>;
		While?: VisitNode<t.While>;
		ExpressionWrapper?: VisitNode<t.ExpressionWrapper>;
		For?: VisitNode<t.For>;
		ForXStatement?: VisitNode<t.ForXStatement>;
		Function?: VisitNode<t.Function>;
		FunctionParent?: VisitNode<t.FunctionParent>;
		Pureish?: VisitNode<t.Pureish>;
		Literal?: VisitNode<t.Literal>;
		Immutable?: VisitNode<t.Immutable>;
		UserWhitespacable?: VisitNode<t.UserWhitespacable>;
		Method?: VisitNode<t.Method>;
		ObjectMember?: VisitNode<t.ObjectMember>;
		Property?: VisitNode<t.Property>;
		UnaryLike?: VisitNode<t.UnaryLike>;
		Pattern?: VisitNode<t.Pattern>;
		Class?: VisitNode<t.Class>;
		ModuleDeclaration?: VisitNode<t.ModuleDeclaration>;
		ExportDeclaration?: VisitNode<t.ExportDeclaration>;
		ModuleSpecifier?: VisitNode<t.ModuleSpecifier>;
		Flow?: VisitNode<t.Flow>;
		FlowBaseAnnotation?: VisitNode<t.FlowBaseAnnotation>;
		FlowDeclaration?: VisitNode<t.FlowDeclaration>;
		JSX?: VisitNode<t.JSX>;
		}

		export type VisitNodeFunction<T> = (path: NodePath<T>, state: any) => void;
		export type VisitNode<T> = VisitNodeFunction<T> \| VisitNodeObject<T>;

		export interface VisitNodeObject<T> {
		enter?(path: NodePath<T>, state: any): void;
		exit?(path: NodePath<T>, state: any): void;
		}
		export type VisitNodeFunction<T> = (path: NodePath<T>, state: any) => void;

		export class NodePath<T> {
		constructor(hub: Hub, parent: Node);
		parent: Node;
		hub: Hub;
		contexts: TraversalContext[];
		data: Object;
		shouldSkip: boolean;
		shouldStop: boolean;
		removed: boolean;
		state: any;
		opts: Object;
		skipKeys: Object;
		parentPath: NodePath<Node>;
		context: TraversalContext;
		container: Object \| Object[];
		listKey: string;
		inList: boolean;
		parentKey: string;
		key: string;
		node: T;
		scope: Scope;
		type: string;
		typeAnnotation: Object;
		export interface VisitNodeObject<T> {
		enter?(path: NodePath<T>, state: any): void;
		exit?(path: NodePath<T>, state: any): void;
		}

		getScope(scope: Scope): Scope;
		export class NodePath<T> {
		constructor(hub: Hub, parent: Node);
		parent: Node;
		hub: Hub;
		contexts: TraversalContext[];
		data: Object;
		shouldSkip: boolean;
		shouldStop: boolean;
		removed: boolean;
		state: any;
		opts: Object;
		skipKeys: Object;
		parentPath: NodePath<Node>;
		context: TraversalContext;
		container: Object \| Object[];
		listKey: string;
		inList: boolean;
		parentKey: string;
		key: string;
		node: T;
		scope: Scope;
		type: string;
		typeAnnotation: Object;

		setData(key: string, val: any): any;
		getScope(scope: Scope): Scope;

		getData(key: string, def?: any): any;
		setData(key: string, val: any): any;

		buildCodeFrameError(msg: string, Error: Error): Error;
		getData(key: string, def?: any): any;

		traverse(visitor: Visitor, state?: any): void;
		buildCodeFrameError(msg: string, Error: Error): Error;

		set(key: string, node: Node): void;
		traverse(visitor: Visitor, state?: any): void;

		getPathLocation(): string;
		set(key: string, node: Node): void;

		debug(buildMessage: Function): void;
		getPathLocation(): string;

		// ------------------------- ancestry -------------------------
		/**
		* Call the provided `callback` with the `NodePath`s of all the parents.
		* When the `callback` returns a truthy value, we return that node path.
		*/
		findParent(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;
		debug(buildMessage: Function): void;

		find(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;
		// ------------------------- ancestry -------------------------
		/**
		* Call the provided `callback` with the `NodePath`s of all the parents.
		* When the `callback` returns a truthy value, we return that node path.
		*/
		findParent(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;

		/** Get the parent function of the current path. */
		getFunctionParent(): NodePath<Node>;
		find(callback: (path: NodePath<Node>) => boolean): NodePath<Node>;

		/** Walk up the tree until we hit a parent node path in a list. */
		getStatementParent(): NodePath<Node>;
		/** Get the parent function of the current path. */
		getFunctionParent(): NodePath<Node>;

		/**
		* Get the deepest common ancestor and then from it, get the earliest relationship path
		* to that ancestor.
		*
		* Earliest is defined as being "before" all the other nodes in terms of list container
		* position and visiting key.
		*/
		getEarliestCommonAncestorFrom(paths: NodePath<Node>[]): NodePath<Node>;
		/** Walk up the tree until we hit a parent node path in a list. */
		getStatementParent(): NodePath<Node>;

		/** Get the earliest path in the tree where the provided `paths` intersect. */
		getDeepestCommonAncestorFrom(paths: NodePath<Node>[], filter?: Function): NodePath<Node>;
		/**
		* Get the deepest common ancestor and then from it, get the earliest relationship path
		* to that ancestor.
		*
		* Earliest is defined as being "before" all the other nodes in terms of list container
		* position and visiting key.
		*/
		getEarliestCommonAncestorFrom(paths: NodePath<Node>[]): NodePath<Node>;

		/**
		* Build an array of node paths containing the entire ancestry of the current node path.
		*
		* NOTE: The current node path is included in this.
		*/
		getAncestry(): NodePath<Node>[];
		/** Get the earliest path in the tree where the provided `paths` intersect. */
		getDeepestCommonAncestorFrom(paths: NodePath<Node>[], filter?: Function): NodePath<Node>;

		inType(...candidateTypes: string[]): boolean;
		/**
		* Build an array of node paths containing the entire ancestry of the current node path.
		*
		* NOTE: The current node path is included in this.
		*/
		getAncestry(): NodePath<Node>[];

		// ------------------------- inference -------------------------
		/** Infer the type of the current `NodePath`. */
		getTypeAnnotation(): t.FlowTypeAnnotation;
		inType(...candidateTypes: string[]): boolean;

		isBaseType(baseName: string, soft?: boolean): boolean;
		// ------------------------- inference -------------------------
		/** Infer the type of the current `NodePath`. */
		getTypeAnnotation(): t.FlowTypeAnnotation;

		couldBeBaseType(name: string): boolean;
		isBaseType(baseName: string, soft?: boolean): boolean;

		baseTypeStrictlyMatches(right: NodePath<Node>): boolean;
		couldBeBaseType(name: string): boolean;

		isGenericType(genericName: string): boolean;
		baseTypeStrictlyMatches(right: NodePath<Node>): boolean;

		// ------------------------- replacement -------------------------
		/**
		* Replace a node with an array of multiple. This method performs the following steps:
		*
		* - Inherit the comments of first provided node with that of the current node.
		* - Insert the provided nodes after the current node.
		* - Remove the current node.
		*/
		replaceWithMultiple(nodes: Node[]): void;
		isGenericType(genericName: string): boolean;

		/**
		* Parse a string as an expression and replace the current node with the result.
		*
		* NOTE: This is typically not a good idea to use. Building source strings when
		* transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's
		* easier to use, your transforms will be extremely brittle.
		*/
		replaceWithSourceString(replacement: any): void;
		// ------------------------- replacement -------------------------
		/**
		* Replace a node with an array of multiple. This method performs the following steps:
		*
		* - Inherit the comments of first provided node with that of the current node.
		* - Insert the provided nodes after the current node.
		* - Remove the current node.
		*/
		replaceWithMultiple(nodes: Node[]): void;

		/** Replace the current node with another. */
		replaceWith(replacement: Node \| NodePath<Node>): void;
		/**
		* Parse a string as an expression and replace the current node with the result.
		*
		* NOTE: This is typically not a good idea to use. Building source strings when
		* transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's
		* easier to use, your transforms will be extremely brittle.
		*/
		replaceWithSourceString(replacement: any): void;

		/**
		* This method takes an array of statements nodes and then explodes it
		* into expressions. This method retains completion records which is
		* extremely important to retain original semantics.
		*/
		replaceExpressionWithStatements(nodes: Node[]): Node;
		/** Replace the current node with another. */
		replaceWith(replacement: Node \| NodePath<Node>): void;

		replaceInline(nodes: Node \| Node[]): void;
		/**
		* This method takes an array of statements nodes and then explodes it
		* into expressions. This method retains completion records which is
		* extremely important to retain original semantics.
		*/
		replaceExpressionWithStatements(nodes: Node[]): Node;

		// ------------------------- evaluation -------------------------
		/**
		* Walk the input `node` and statically evaluate if it's truthy.
		*
		* Returning `true` when we're sure that the expression will evaluate to a
		* truthy value, `false` if we're sure that it will evaluate to a falsy
		* value and `undefined` if we aren't sure. Because of this please do not
		* rely on coercion when using this method and check with === if it's false.
		*/
		evaluateTruthy(): boolean;
		replaceInline(nodes: Node \| Node[]): void;

		/**
		* Walk the input `node` and statically evaluate it.
		*
		* Returns an object in the form `{ confident, value }`. `confident` indicates
		* whether or not we had to drop out of evaluating the expression because of
		* hitting an unknown node that we couldn't confidently find the value of.
		*
		* Example:
		*
		* t.evaluate(parse("5 + 5")) // { confident: true, value: 10 }
		* t.evaluate(parse("!true")) // { confident: true, value: false }
		* t.evaluate(parse("foo + foo")) // { confident: false, value: undefined }
		*/
		evaluate(): { confident: boolean; value: any };
		// ------------------------- evaluation -------------------------
		/**
		* Walk the input `node` and statically evaluate if it's truthy.
		*
		* Returning `true` when we're sure that the expression will evaluate to a
		* truthy value, `false` if we're sure that it will evaluate to a falsy
		* value and `undefined` if we aren't sure. Because of this please do not
		* rely on coercion when using this method and check with === if it's false.
		*/
		evaluateTruthy(): boolean;

		// ------------------------- introspection -------------------------
		/**
		* Match the current node if it matches the provided `pattern`.
		*
		* For example, given the match `React.createClass` it would match the
		* parsed nodes of `React.createClass` and `React["createClass"]`.
		*/
		matchesPattern(pattern: string, allowPartial?: boolean): boolean;
		/**
		* Walk the input `node` and statically evaluate it.
		*
		* Returns an object in the form `{ confident, value }`. `confident` indicates
		* whether or not we had to drop out of evaluating the expression because of
		* hitting an unknown node that we couldn't confidently find the value of.
		*
		* Example:
		*
		* t.evaluate(parse("5 + 5")) // { confident: true, value: 10 }
		* t.evaluate(parse("!true")) // { confident: true, value: false }
		* t.evaluate(parse("foo + foo")) // { confident: false, value: undefined }
		*/
		evaluate(): { confident: boolean; value: any };

		/**
		* Check whether we have the input `key`. If the `key` references an array then we check
		* if the array has any items, otherwise we just check if it's falsy.
		*/
		has(key: string): boolean;
		// ------------------------- introspection -------------------------
		/**
		* Match the current node if it matches the provided `pattern`.
		*
		* For example, given the match `React.createClass` it would match the
		* parsed nodes of `React.createClass` and `React["createClass"]`.
		*/
		matchesPattern(pattern: string, allowPartial?: boolean): boolean;

		isStatic(): boolean;
		/**
		* Check whether we have the input `key`. If the `key` references an array then we check
		* if the array has any items, otherwise we just check if it's falsy.
		*/
		has(key: string): boolean;

		/** Alias of `has`. */
		is(key: string): boolean;
		isStatic(): boolean;

		/** Opposite of `has`. */
		isnt(key: string): boolean;
		/** Alias of `has`. */
		is(key: string): boolean;

		/** Check whether the path node `key` strict equals `value`. */
		equals(key: string, value: any): boolean;
		/** Opposite of `has`. */
		isnt(key: string): boolean;

		/**
		* Check the type against our stored internal type of the node. This is handy when a node has
		* been removed yet we still internally know the type and need it to calculate node replacement.
		*/
		isNodeType(type: string): boolean;
		/** Check whether the path node `key` strict equals `value`. */
		equals(key: string, value: any): boolean;

		/**
		* This checks whether or not we're in one of the following positions:
		*
		* for (KEY in right);
		* for (KEY;;);
		*
		* This is because these spots allow VariableDeclarations AND normal expressions so we need
		* to tell the path replacement that it's ok to replace this with an expression.
		*/
		canHaveVariableDeclarationOrExpression(): boolean;
		/**
		* Check the type against our stored internal type of the node. This is handy when a node has
		* been removed yet we still internally know the type and need it to calculate node replacement.
		*/
		isNodeType(type: string): boolean;

		/**
		* This checks whether we are swapping an arrow function's body between an
		* expression and a block statement (or vice versa).
		*
		* This is because arrow functions may implicitly return an expression, which
		* is the same as containing a block statement.
		*/
		canSwapBetweenExpressionAndStatement(replacement: Node): boolean;
		/**
		* This checks whether or not we're in one of the following positions:
		*
		* for (KEY in right);
		* for (KEY;;);
		*
		* This is because these spots allow VariableDeclarations AND normal expressions so we need
		* to tell the path replacement that it's ok to replace this with an expression.
		*/
		canHaveVariableDeclarationOrExpression(): boolean;

		/** Check whether the current path references a completion record */
		isCompletionRecord(allowInsideFunction?: boolean): boolean;
		/**
		* This checks whether we are swapping an arrow function's body between an
		* expression and a block statement (or vice versa).
		*
		* This is because arrow functions may implicitly return an expression, which
		* is the same as containing a block statement.
		*/
		canSwapBetweenExpressionAndStatement(replacement: Node): boolean;

		/**
		* Check whether or not the current `key` allows either a single statement or block statement
		* so we can explode it if necessary.
		*/
		isStatementOrBlock(): boolean;
		/** Check whether the current path references a completion record */
		isCompletionRecord(allowInsideFunction?: boolean): boolean;

		/** Check if the currently assigned path references the `importName` of `moduleSource`. */
		referencesImport(moduleSource: string, importName: string): boolean;
		/**
		* Check whether or not the current `key` allows either a single statement or block statement
		* so we can explode it if necessary.
		*/
		isStatementOrBlock(): boolean;

		/** Get the source code associated with this node. */
		getSource(): string;
		/** Check if the currently assigned path references the `importName` of `moduleSource`. */
		referencesImport(moduleSource: string, importName: string): boolean;

		// ------------------------- context -------------------------
		call(key: string): boolean;
		/** Get the source code associated with this node. */
		getSource(): string;

		isBlacklisted(): boolean;
		// ------------------------- context -------------------------
		call(key: string): boolean;

		visit(): boolean;
		isBlacklisted(): boolean;

		skip(): void;
		visit(): boolean;

		skipKey(key: string): void;
		skip(): void;

		stop(): void;
		skipKey(key: string): void;

		setScope(): void;
		stop(): void;

		setContext(context: TraversalContext): NodePath<T>;
		setScope(): void;

		popContext(): void;
		setContext(context: TraversalContext): NodePath<T>;

		pushContext(context: TraversalContext): void;
		popContext(): void;

		// ------------------------- removal -------------------------
		remove(): void;
		pushContext(context: TraversalContext): void;

		// ------------------------- modification -------------------------
		/** Insert the provided nodes before the current one. */
		insertBefore(nodes: Node \| Node[]): any;
		// ------------------------- removal -------------------------
		remove(): void;

		/**
		* Insert the provided nodes after the current one. When inserting nodes after an
		* expression, ensure that the completion record is correct by pushing the current node.
		*/
		insertAfter(nodes: Node \| Node[]): any;
		// ------------------------- modification -------------------------
		/** Insert the provided nodes before the current one. */
		insertBefore(nodes: Node \| Node[]): any;

		/** Update all sibling node paths after `fromIndex` by `incrementBy`. */
		updateSiblingKeys(fromIndex: number, incrementBy: number): void;
		/**
		* Insert the provided nodes after the current one. When inserting nodes after an
		* expression, ensure that the completion record is correct by pushing the current node.
		*/
		insertAfter(nodes: Node \| Node[]): any;

		/** Hoist the current node to the highest scope possible and return a UID referencing it. */
		hoist(scope: Scope): void;
		/** Update all sibling node paths after `fromIndex` by `incrementBy`. */
		updateSiblingKeys(fromIndex: number, incrementBy: number): void;

		// ------------------------- family -------------------------
		getStatementParent(): NodePath<Node>;
		/** Hoist the current node to the highest scope possible and return a UID referencing it. */
		hoist(scope: Scope): void;

		getOpposite(): NodePath<Node>;
		// ------------------------- family -------------------------
		getStatementParent(): NodePath<Node>;

		getCompletionRecords(): NodePath<Node>[];
		getOpposite(): NodePath<Node>;

		getSibling(key: string): NodePath<Node>;
		getCompletionRecords(): NodePath<Node>[];

		get(key: string, context?: boolean \| TraversalContext): NodePath<Node>;
		getSibling(key: string): NodePath<Node>;

		getBindingIdentifiers(duplicates?: boolean): Node[];
		get(key: string, context?: boolean \| TraversalContext): NodePath<Node>;

		getOuterBindingIdentifiers(duplicates?: boolean): Node[];
		getBindingIdentifiers(duplicates?: boolean): Node[];

		// ------------------------- comments -------------------------
		/** Share comments amongst siblings. */
		shareCommentsWithSiblings(): void;
		getOuterBindingIdentifiers(duplicates?: boolean): Node[];

		addComment(type: string, content: string, line?: boolean): void;
		// ------------------------- comments -------------------------
		/** Share comments amongst siblings. */
		shareCommentsWithSiblings(): void;

		/** Give node `comments` of the specified `type`. */
		addComments(type: string, comments: any[]): void;
		addComment(type: string, content: string, line?: boolean): void;

		// ------------------------- isXXX -------------------------
		isArrayExpression(opts?: Object): boolean;
		isAssignmentExpression(opts?: Object): boolean;
		isBinaryExpression(opts?: Object): boolean;
		isDirective(opts?: Object): boolean;
		isDirectiveLiteral(opts?: Object): boolean;
		isBlockStatement(opts?: Object): boolean;
		isBreakStatement(opts?: Object): boolean;
		isCallExpression(opts?: Object): boolean;
		isCatchClause(opts?: Object): boolean;
		isConditionalExpression(opts?: Object): boolean;
		isContinueStatement(opts?: Object): boolean;
		isDebuggerStatement(opts?: Object): boolean;
		isDoWhileStatement(opts?: Object): boolean;
		isEmptyStatement(opts?: Object): boolean;
		isExpressionStatement(opts?: Object): boolean;
		isFile(opts?: Object): boolean;
		isForInStatement(opts?: Object): boolean;
		isForStatement(opts?: Object): boolean;
		isFunctionDeclaration(opts?: Object): boolean;
		isFunctionExpression(opts?: Object): boolean;
		isIdentifier(opts?: Object): boolean;
		isIfStatement(opts?: Object): boolean;
		isLabeledStatement(opts?: Object): boolean;
		isStringLiteral(opts?: Object): boolean;
		isNumericLiteral(opts?: Object): boolean;
		isNullLiteral(opts?: Object): boolean;
		isBooleanLiteral(opts?: Object): boolean;
		isRegExpLiteral(opts?: Object): boolean;
		isLogicalExpression(opts?: Object): boolean;
		isMemberExpression(opts?: Object): boolean;
		isNewExpression(opts?: Object): boolean;
		isProgram(opts?: Object): boolean;
		isObjectExpression(opts?: Object): boolean;
		isObjectMethod(opts?: Object): boolean;
		isObjectProperty(opts?: Object): boolean;
		isRestElement(opts?: Object): boolean;
		isReturnStatement(opts?: Object): boolean;
		isSequenceExpression(opts?: Object): boolean;
		isSwitchCase(opts?: Object): boolean;
		isSwitchStatement(opts?: Object): boolean;
		isThisExpression(opts?: Object): boolean;
		isThrowStatement(opts?: Object): boolean;
		isTryStatement(opts?: Object): boolean;
		isUnaryExpression(opts?: Object): boolean;
		isUpdateExpression(opts?: Object): boolean;
		isVariableDeclaration(opts?: Object): boolean;
		isVariableDeclarator(opts?: Object): boolean;
		isWhileStatement(opts?: Object): boolean;
		isWithStatement(opts?: Object): boolean;
		isAssignmentPattern(opts?: Object): boolean;
		isArrayPattern(opts?: Object): boolean;
		isArrowFunctionExpression(opts?: Object): boolean;
		isClassBody(opts?: Object): boolean;
		isClassDeclaration(opts?: Object): boolean;
		isClassExpression(opts?: Object): boolean;
		isExportAllDeclaration(opts?: Object): boolean;
		isExportDefaultDeclaration(opts?: Object): boolean;
		isExportNamedDeclaration(opts?: Object): boolean;
		isExportSpecifier(opts?: Object): boolean;
		isForOfStatement(opts?: Object): boolean;
		isImportDeclaration(opts?: Object): boolean;
		isImportDefaultSpecifier(opts?: Object): boolean;
		isImportNamespaceSpecifier(opts?: Object): boolean;
		isImportSpecifier(opts?: Object): boolean;
		isMetaProperty(opts?: Object): boolean;
		isClassMethod(opts?: Object): boolean;
		isObjectPattern(opts?: Object): boolean;
		isSpreadElement(opts?: Object): boolean;
		isSuper(opts?: Object): boolean;
		isTaggedTemplateExpression(opts?: Object): boolean;
		isTemplateElement(opts?: Object): boolean;
		isTemplateLiteral(opts?: Object): boolean;
		isYieldExpression(opts?: Object): boolean;
		isAnyTypeAnnotation(opts?: Object): boolean;
		isArrayTypeAnnotation(opts?: Object): boolean;
		isBooleanTypeAnnotation(opts?: Object): boolean;
		isBooleanLiteralTypeAnnotation(opts?: Object): boolean;
		isNullLiteralTypeAnnotation(opts?: Object): boolean;
		isClassImplements(opts?: Object): boolean;
		isClassProperty(opts?: Object): boolean;
		isDeclareClass(opts?: Object): boolean;
		isDeclareFunction(opts?: Object): boolean;
		isDeclareInterface(opts?: Object): boolean;
		isDeclareModule(opts?: Object): boolean;
		isDeclareTypeAlias(opts?: Object): boolean;
		isDeclareVariable(opts?: Object): boolean;
		isExistentialTypeParam(opts?: Object): boolean;
		isFunctionTypeAnnotation(opts?: Object): boolean;
		isFunctionTypeParam(opts?: Object): boolean;
		isGenericTypeAnnotation(opts?: Object): boolean;
		isInterfaceExtends(opts?: Object): boolean;
		isInterfaceDeclaration(opts?: Object): boolean;
		isIntersectionTypeAnnotation(opts?: Object): boolean;
		isMixedTypeAnnotation(opts?: Object): boolean;
		isNullableTypeAnnotation(opts?: Object): boolean;
		isNumericLiteralTypeAnnotation(opts?: Object): boolean;
		isNumberTypeAnnotation(opts?: Object): boolean;
		isStringLiteralTypeAnnotation(opts?: Object): boolean;
		isStringTypeAnnotation(opts?: Object): boolean;
		isThisTypeAnnotation(opts?: Object): boolean;
		isTupleTypeAnnotation(opts?: Object): boolean;
		isTypeofTypeAnnotation(opts?: Object): boolean;
		isTypeAlias(opts?: Object): boolean;
		isTypeAnnotation(opts?: Object): boolean;
		isTypeCastExpression(opts?: Object): boolean;
		isTypeParameterDeclaration(opts?: Object): boolean;
		isTypeParameterInstantiation(opts?: Object): boolean;
		isObjectTypeAnnotation(opts?: Object): boolean;
		isObjectTypeCallProperty(opts?: Object): boolean;
		isObjectTypeIndexer(opts?: Object): boolean;
		isObjectTypeProperty(opts?: Object): boolean;
		isQualifiedTypeIdentifier(opts?: Object): boolean;
		isUnionTypeAnnotation(opts?: Object): boolean;
		isVoidTypeAnnotation(opts?: Object): boolean;
		isJSXAttribute(opts?: Object): boolean;
		isJSXClosingElement(opts?: Object): boolean;
		isJSXElement(opts?: Object): boolean;
		isJSXEmptyExpression(opts?: Object): boolean;
		isJSXExpressionContainer(opts?: Object): boolean;
		isJSXIdentifier(opts?: Object): boolean;
		isJSXMemberExpression(opts?: Object): boolean;
		isJSXNamespacedName(opts?: Object): boolean;
		isJSXOpeningElement(opts?: Object): boolean;
		isJSXSpreadAttribute(opts?: Object): boolean;
		isJSXText(opts?: Object): boolean;
		isNoop(opts?: Object): boolean;
		isParenthesizedExpression(opts?: Object): boolean;
		isAwaitExpression(opts?: Object): boolean;
		isBindExpression(opts?: Object): boolean;
		isDecorator(opts?: Object): boolean;
		isDoExpression(opts?: Object): boolean;
		isExportDefaultSpecifier(opts?: Object): boolean;
		isExportNamespaceSpecifier(opts?: Object): boolean;
		isRestProperty(opts?: Object): boolean;
		isSpreadProperty(opts?: Object): boolean;
		isExpression(opts?: Object): boolean;
		isBinary(opts?: Object): boolean;
		isScopable(opts?: Object): boolean;
		isBlockParent(opts?: Object): boolean;
		isBlock(opts?: Object): boolean;
		isStatement(opts?: Object): boolean;
		isTerminatorless(opts?: Object): boolean;
		isCompletionStatement(opts?: Object): boolean;
		isConditional(opts?: Object): boolean;
		isLoop(opts?: Object): boolean;
		isWhile(opts?: Object): boolean;
		isExpressionWrapper(opts?: Object): boolean;
		isFor(opts?: Object): boolean;
		isForXStatement(opts?: Object): boolean;
		isFunction(opts?: Object): boolean;
		isFunctionParent(opts?: Object): boolean;
		isPureish(opts?: Object): boolean;
		isDeclaration(opts?: Object): boolean;
		isLVal(opts?: Object): boolean;
		isLiteral(opts?: Object): boolean;
		isImmutable(opts?: Object): boolean;
		isUserWhitespacable(opts?: Object): boolean;
		isMethod(opts?: Object): boolean;
		isObjectMember(opts?: Object): boolean;
		isProperty(opts?: Object): boolean;
		isUnaryLike(opts?: Object): boolean;
		isPattern(opts?: Object): boolean;
		isClass(opts?: Object): boolean;
		isModuleDeclaration(opts?: Object): boolean;
		isExportDeclaration(opts?: Object): boolean;
		isModuleSpecifier(opts?: Object): boolean;
		isFlow(opts?: Object): boolean;
		isFlowBaseAnnotation(opts?: Object): boolean;
		isFlowDeclaration(opts?: Object): boolean;
		isJSX(opts?: Object): boolean;
		isNumberLiteral(opts?: Object): boolean;
		isRegexLiteral(opts?: Object): boolean;
		isReferencedIdentifier(opts?: Object): boolean;
		isReferencedMemberExpression(opts?: Object): boolean;
		isBindingIdentifier(opts?: Object): boolean;
		isScope(opts?: Object): boolean;
		isReferenced(opts?: Object): boolean;
		isBlockScoped(opts?: Object): boolean;
		isVar(opts?: Object): boolean;
		isUser(opts?: Object): boolean;
		isGenerated(opts?: Object): boolean;
		isPure(opts?: Object): boolean;
		/** Give node `comments` of the specified `type`. */
		addComments(type: string, comments: any[]): void;

		// ------------------------- assertXXX -------------------------
		assertArrayExpression(opts?: Object): void;
		assertAssignmentExpression(opts?: Object): void;
		assertBinaryExpression(opts?: Object): void;
		assertDirective(opts?: Object): void;
		assertDirectiveLiteral(opts?: Object): void;
		assertBlockStatement(opts?: Object): void;
		assertBreakStatement(opts?: Object): void;
		assertCallExpression(opts?: Object): void;
		assertCatchClause(opts?: Object): void;
		assertConditionalExpression(opts?: Object): void;
		assertContinueStatement(opts?: Object): void;
		assertDebuggerStatement(opts?: Object): void;
		assertDoWhileStatement(opts?: Object): void;
		assertEmptyStatement(opts?: Object): void;
		assertExpressionStatement(opts?: Object): void;
		assertFile(opts?: Object): void;
		assertForInStatement(opts?: Object): void;
		assertForStatement(opts?: Object): void;
		assertFunctionDeclaration(opts?: Object): void;
		assertFunctionExpression(opts?: Object): void;
		assertIdentifier(opts?: Object): void;
		assertIfStatement(opts?: Object): void;
		assertLabeledStatement(opts?: Object): void;
		assertStringLiteral(opts?: Object): void;
		assertNumericLiteral(opts?: Object): void;
		assertNullLiteral(opts?: Object): void;
		assertBooleanLiteral(opts?: Object): void;
		assertRegExpLiteral(opts?: Object): void;
		assertLogicalExpression(opts?: Object): void;
		assertMemberExpression(opts?: Object): void;
		assertNewExpression(opts?: Object): void;
		assertProgram(opts?: Object): void;
		assertObjectExpression(opts?: Object): void;
		assertObjectMethod(opts?: Object): void;
		assertObjectProperty(opts?: Object): void;
		assertRestElement(opts?: Object): void;
		assertReturnStatement(opts?: Object): void;
		assertSequenceExpression(opts?: Object): void;
		assertSwitchCase(opts?: Object): void;
		assertSwitchStatement(opts?: Object): void;
		assertThisExpression(opts?: Object): void;
		assertThrowStatement(opts?: Object): void;
		assertTryStatement(opts?: Object): void;
		assertUnaryExpression(opts?: Object): void;
		assertUpdateExpression(opts?: Object): void;
		assertVariableDeclaration(opts?: Object): void;
		assertVariableDeclarator(opts?: Object): void;
		assertWhileStatement(opts?: Object): void;
		assertWithStatement(opts?: Object): void;
		assertAssignmentPattern(opts?: Object): void;
		assertArrayPattern(opts?: Object): void;
		assertArrowFunctionExpression(opts?: Object): void;
		assertClassBody(opts?: Object): void;
		assertClassDeclaration(opts?: Object): void;
		assertClassExpression(opts?: Object): void;
		assertExportAllDeclaration(opts?: Object): void;
		assertExportDefaultDeclaration(opts?: Object): void;
		assertExportNamedDeclaration(opts?: Object): void;
		assertExportSpecifier(opts?: Object): void;
		assertForOfStatement(opts?: Object): void;
		assertImportDeclaration(opts?: Object): void;
		assertImportDefaultSpecifier(opts?: Object): void;
		assertImportNamespaceSpecifier(opts?: Object): void;
		assertImportSpecifier(opts?: Object): void;
		assertMetaProperty(opts?: Object): void;
		assertClassMethod(opts?: Object): void;
		assertObjectPattern(opts?: Object): void;
		assertSpreadElement(opts?: Object): void;
		assertSuper(opts?: Object): void;
		assertTaggedTemplateExpression(opts?: Object): void;
		assertTemplateElement(opts?: Object): void;
		assertTemplateLiteral(opts?: Object): void;
		assertYieldExpression(opts?: Object): void;
		assertAnyTypeAnnotation(opts?: Object): void;
		assertArrayTypeAnnotation(opts?: Object): void;
		assertBooleanTypeAnnotation(opts?: Object): void;
		assertBooleanLiteralTypeAnnotation(opts?: Object): void;
		assertNullLiteralTypeAnnotation(opts?: Object): void;
		assertClassImplements(opts?: Object): void;
		assertClassProperty(opts?: Object): void;
		assertDeclareClass(opts?: Object): void;
		assertDeclareFunction(opts?: Object): void;
		assertDeclareInterface(opts?: Object): void;
		assertDeclareModule(opts?: Object): void;
		assertDeclareTypeAlias(opts?: Object): void;
		assertDeclareVariable(opts?: Object): void;
		assertExistentialTypeParam(opts?: Object): void;
		assertFunctionTypeAnnotation(opts?: Object): void;
		assertFunctionTypeParam(opts?: Object): void;
		assertGenericTypeAnnotation(opts?: Object): void;
		assertInterfaceExtends(opts?: Object): void;
		assertInterfaceDeclaration(opts?: Object): void;
		assertIntersectionTypeAnnotation(opts?: Object): void;
		assertMixedTypeAnnotation(opts?: Object): void;
		assertNullableTypeAnnotation(opts?: Object): void;
		assertNumericLiteralTypeAnnotation(opts?: Object): void;
		assertNumberTypeAnnotation(opts?: Object): void;
		assertStringLiteralTypeAnnotation(opts?: Object): void;
		assertStringTypeAnnotation(opts?: Object): void;
		assertThisTypeAnnotation(opts?: Object): void;
		assertTupleTypeAnnotation(opts?: Object): void;
		assertTypeofTypeAnnotation(opts?: Object): void;
		assertTypeAlias(opts?: Object): void;
		assertTypeAnnotation(opts?: Object): void;
		assertTypeCastExpression(opts?: Object): void;
		assertTypeParameterDeclaration(opts?: Object): void;
		assertTypeParameterInstantiation(opts?: Object): void;
		assertObjectTypeAnnotation(opts?: Object): void;
		assertObjectTypeCallProperty(opts?: Object): void;
		assertObjectTypeIndexer(opts?: Object): void;
		assertObjectTypeProperty(opts?: Object): void;
		assertQualifiedTypeIdentifier(opts?: Object): void;
		assertUnionTypeAnnotation(opts?: Object): void;
		assertVoidTypeAnnotation(opts?: Object): void;
		assertJSXAttribute(opts?: Object): void;
		assertJSXClosingElement(opts?: Object): void;
		assertJSXElement(opts?: Object): void;
		assertJSXEmptyExpression(opts?: Object): void;
		assertJSXExpressionContainer(opts?: Object): void;
		assertJSXIdentifier(opts?: Object): void;
		assertJSXMemberExpression(opts?: Object): void;
		assertJSXNamespacedName(opts?: Object): void;
		assertJSXOpeningElement(opts?: Object): void;
		assertJSXSpreadAttribute(opts?: Object): void;
		assertJSXText(opts?: Object): void;
		assertNoop(opts?: Object): void;
		assertParenthesizedExpression(opts?: Object): void;
		assertAwaitExpression(opts?: Object): void;
		assertBindExpression(opts?: Object): void;
		assertDecorator(opts?: Object): void;
		assertDoExpression(opts?: Object): void;
		assertExportDefaultSpecifier(opts?: Object): void;
		assertExportNamespaceSpecifier(opts?: Object): void;
		assertRestProperty(opts?: Object): void;
		assertSpreadProperty(opts?: Object): void;
		assertExpression(opts?: Object): void;
		assertBinary(opts?: Object): void;
		assertScopable(opts?: Object): void;
		assertBlockParent(opts?: Object): void;
		assertBlock(opts?: Object): void;
		assertStatement(opts?: Object): void;
		assertTerminatorless(opts?: Object): void;
		assertCompletionStatement(opts?: Object): void;
		assertConditional(opts?: Object): void;
		assertLoop(opts?: Object): void;
		assertWhile(opts?: Object): void;
		assertExpressionWrapper(opts?: Object): void;
		assertFor(opts?: Object): void;
		assertForXStatement(opts?: Object): void;
		assertFunction(opts?: Object): void;
		assertFunctionParent(opts?: Object): void;
		assertPureish(opts?: Object): void;
		assertDeclaration(opts?: Object): void;
		assertLVal(opts?: Object): void;
		assertLiteral(opts?: Object): void;
		assertImmutable(opts?: Object): void;
		assertUserWhitespacable(opts?: Object): void;
		assertMethod(opts?: Object): void;
		assertObjectMember(opts?: Object): void;
		assertProperty(opts?: Object): void;
		assertUnaryLike(opts?: Object): void;
		assertPattern(opts?: Object): void;
		assertClass(opts?: Object): void;
		assertModuleDeclaration(opts?: Object): void;
		assertExportDeclaration(opts?: Object): void;
		assertModuleSpecifier(opts?: Object): void;
		assertFlow(opts?: Object): void;
		assertFlowBaseAnnotation(opts?: Object): void;
		assertFlowDeclaration(opts?: Object): void;
		assertJSX(opts?: Object): void;
		assertNumberLiteral(opts?: Object): void;
		assertRegexLiteral(opts?: Object): void;
		}
		// ------------------------- isXXX -------------------------
		isArrayExpression(opts?: Object): boolean;
		isAssignmentExpression(opts?: Object): boolean;
		isBinaryExpression(opts?: Object): boolean;
		isDirective(opts?: Object): boolean;
		isDirectiveLiteral(opts?: Object): boolean;
		isBlockStatement(opts?: Object): boolean;
		isBreakStatement(opts?: Object): boolean;
		isCallExpression(opts?: Object): boolean;
		isCatchClause(opts?: Object): boolean;
		isConditionalExpression(opts?: Object): boolean;
		isContinueStatement(opts?: Object): boolean;
		isDebuggerStatement(opts?: Object): boolean;
		isDoWhileStatement(opts?: Object): boolean;
		isEmptyStatement(opts?: Object): boolean;
		isExpressionStatement(opts?: Object): boolean;
		isFile(opts?: Object): boolean;
		isForInStatement(opts?: Object): boolean;
		isForStatement(opts?: Object): boolean;
		isFunctionDeclaration(opts?: Object): boolean;
		isFunctionExpression(opts?: Object): boolean;
		isIdentifier(opts?: Object): boolean;
		isIfStatement(opts?: Object): boolean;
		isLabeledStatement(opts?: Object): boolean;
		isStringLiteral(opts?: Object): boolean;
		isNumericLiteral(opts?: Object): boolean;
		isNullLiteral(opts?: Object): boolean;
		isBooleanLiteral(opts?: Object): boolean;
		isRegExpLiteral(opts?: Object): boolean;
		isLogicalExpression(opts?: Object): boolean;
		isMemberExpression(opts?: Object): boolean;
		isNewExpression(opts?: Object): boolean;
		isProgram(opts?: Object): boolean;
		isObjectExpression(opts?: Object): boolean;
		isObjectMethod(opts?: Object): boolean;
		isObjectProperty(opts?: Object): boolean;
		isRestElement(opts?: Object): boolean;
		isReturnStatement(opts?: Object): boolean;
		isSequenceExpression(opts?: Object): boolean;
		isSwitchCase(opts?: Object): boolean;
		isSwitchStatement(opts?: Object): boolean;
		isThisExpression(opts?: Object): boolean;
		isThrowStatement(opts?: Object): boolean;
		isTryStatement(opts?: Object): boolean;
		isUnaryExpression(opts?: Object): boolean;
		isUpdateExpression(opts?: Object): boolean;
		isVariableDeclaration(opts?: Object): boolean;
		isVariableDeclarator(opts?: Object): boolean;
		isWhileStatement(opts?: Object): boolean;
		isWithStatement(opts?: Object): boolean;
		isAssignmentPattern(opts?: Object): boolean;
		isArrayPattern(opts?: Object): boolean;
		isArrowFunctionExpression(opts?: Object): boolean;
		isClassBody(opts?: Object): boolean;
		isClassDeclaration(opts?: Object): boolean;
		isClassExpression(opts?: Object): boolean;
		isExportAllDeclaration(opts?: Object): boolean;
		isExportDefaultDeclaration(opts?: Object): boolean;
		isExportNamedDeclaration(opts?: Object): boolean;
		isExportSpecifier(opts?: Object): boolean;
		isForOfStatement(opts?: Object): boolean;
		isImportDeclaration(opts?: Object): boolean;
		isImportDefaultSpecifier(opts?: Object): boolean;
		isImportNamespaceSpecifier(opts?: Object): boolean;
		isImportSpecifier(opts?: Object): boolean;
		isMetaProperty(opts?: Object): boolean;
		isClassMethod(opts?: Object): boolean;
		isObjectPattern(opts?: Object): boolean;
		isSpreadElement(opts?: Object): boolean;
		isSuper(opts?: Object): boolean;
		isTaggedTemplateExpression(opts?: Object): boolean;
		isTemplateElement(opts?: Object): boolean;
		isTemplateLiteral(opts?: Object): boolean;
		isYieldExpression(opts?: Object): boolean;
		isAnyTypeAnnotation(opts?: Object): boolean;
		isArrayTypeAnnotation(opts?: Object): boolean;
		isBooleanTypeAnnotation(opts?: Object): boolean;
		isBooleanLiteralTypeAnnotation(opts?: Object): boolean;
		isNullLiteralTypeAnnotation(opts?: Object): boolean;
		isClassImplements(opts?: Object): boolean;
		isClassProperty(opts?: Object): boolean;
		isDeclareClass(opts?: Object): boolean;
		isDeclareFunction(opts?: Object): boolean;
		isDeclareInterface(opts?: Object): boolean;
		isDeclareModule(opts?: Object): boolean;
		isDeclareTypeAlias(opts?: Object): boolean;
		isDeclareVariable(opts?: Object): boolean;
		isExistentialTypeParam(opts?: Object): boolean;
		isFunctionTypeAnnotation(opts?: Object): boolean;
		isFunctionTypeParam(opts?: Object): boolean;
		isGenericTypeAnnotation(opts?: Object): boolean;
		isInterfaceExtends(opts?: Object): boolean;
		isInterfaceDeclaration(opts?: Object): boolean;
		isIntersectionTypeAnnotation(opts?: Object): boolean;
		isMixedTypeAnnotation(opts?: Object): boolean;
		isNullableTypeAnnotation(opts?: Object): boolean;
		isNumericLiteralTypeAnnotation(opts?: Object): boolean;
		isNumberTypeAnnotation(opts?: Object): boolean;
		isStringLiteralTypeAnnotation(opts?: Object): boolean;
		isStringTypeAnnotation(opts?: Object): boolean;
		isThisTypeAnnotation(opts?: Object): boolean;
		isTupleTypeAnnotation(opts?: Object): boolean;
		isTypeofTypeAnnotation(opts?: Object): boolean;
		isTypeAlias(opts?: Object): boolean;
		isTypeAnnotation(opts?: Object): boolean;
		isTypeCastExpression(opts?: Object): boolean;
		isTypeParameterDeclaration(opts?: Object): boolean;
		isTypeParameterInstantiation(opts?: Object): boolean;
		isObjectTypeAnnotation(opts?: Object): boolean;
		isObjectTypeCallProperty(opts?: Object): boolean;
		isObjectTypeIndexer(opts?: Object): boolean;
		isObjectTypeProperty(opts?: Object): boolean;
		isQualifiedTypeIdentifier(opts?: Object): boolean;
		isUnionTypeAnnotation(opts?: Object): boolean;
		isVoidTypeAnnotation(opts?: Object): boolean;
		isJSXAttribute(opts?: Object): boolean;
		isJSXClosingElement(opts?: Object): boolean;
		isJSXElement(opts?: Object): boolean;
		isJSXEmptyExpression(opts?: Object): boolean;
		isJSXExpressionContainer(opts?: Object): boolean;
		isJSXIdentifier(opts?: Object): boolean;
		isJSXMemberExpression(opts?: Object): boolean;
		isJSXNamespacedName(opts?: Object): boolean;
		isJSXOpeningElement(opts?: Object): boolean;
		isJSXSpreadAttribute(opts?: Object): boolean;
		isJSXText(opts?: Object): boolean;
		isNoop(opts?: Object): boolean;
		isParenthesizedExpression(opts?: Object): boolean;
		isAwaitExpression(opts?: Object): boolean;
		isBindExpression(opts?: Object): boolean;
		isDecorator(opts?: Object): boolean;
		isDoExpression(opts?: Object): boolean;
		isExportDefaultSpecifier(opts?: Object): boolean;
		isExportNamespaceSpecifier(opts?: Object): boolean;
		isRestProperty(opts?: Object): boolean;
		isSpreadProperty(opts?: Object): boolean;
		isExpression(opts?: Object): boolean;
		isBinary(opts?: Object): boolean;
		isScopable(opts?: Object): boolean;
		isBlockParent(opts?: Object): boolean;
		isBlock(opts?: Object): boolean;
		isStatement(opts?: Object): boolean;
		isTerminatorless(opts?: Object): boolean;
		isCompletionStatement(opts?: Object): boolean;
		isConditional(opts?: Object): boolean;
		isLoop(opts?: Object): boolean;
		isWhile(opts?: Object): boolean;
		isExpressionWrapper(opts?: Object): boolean;
		isFor(opts?: Object): boolean;
		isForXStatement(opts?: Object): boolean;
		isFunction(opts?: Object): boolean;
		isFunctionParent(opts?: Object): boolean;
		isPureish(opts?: Object): boolean;
		isDeclaration(opts?: Object): boolean;
		isLVal(opts?: Object): boolean;
		isLiteral(opts?: Object): boolean;
		isImmutable(opts?: Object): boolean;
		isUserWhitespacable(opts?: Object): boolean;
		isMethod(opts?: Object): boolean;
		isObjectMember(opts?: Object): boolean;
		isProperty(opts?: Object): boolean;
		isUnaryLike(opts?: Object): boolean;
		isPattern(opts?: Object): boolean;
		isClass(opts?: Object): boolean;
		isModuleDeclaration(opts?: Object): boolean;
		isExportDeclaration(opts?: Object): boolean;
		isModuleSpecifier(opts?: Object): boolean;
		isFlow(opts?: Object): boolean;
		isFlowBaseAnnotation(opts?: Object): boolean;
		isFlowDeclaration(opts?: Object): boolean;
		isJSX(opts?: Object): boolean;
		isNumberLiteral(opts?: Object): boolean;
		isRegexLiteral(opts?: Object): boolean;
		isReferencedIdentifier(opts?: Object): boolean;
		isReferencedMemberExpression(opts?: Object): boolean;
		isBindingIdentifier(opts?: Object): boolean;
		isScope(opts?: Object): boolean;
		isReferenced(opts?: Object): boolean;
		isBlockScoped(opts?: Object): boolean;
		isVar(opts?: Object): boolean;
		isUser(opts?: Object): boolean;
		isGenerated(opts?: Object): boolean;
		isPure(opts?: Object): boolean;

		export class Hub {
		constructor(file: any, options: any);
		file: any;
		options: any;
		}
		// ------------------------- assertXXX -------------------------
		assertArrayExpression(opts?: Object): void;
		assertAssignmentExpression(opts?: Object): void;
		assertBinaryExpression(opts?: Object): void;
		assertDirective(opts?: Object): void;
		assertDirectiveLiteral(opts?: Object): void;
		assertBlockStatement(opts?: Object): void;
		assertBreakStatement(opts?: Object): void;
		assertCallExpression(opts?: Object): void;
		assertCatchClause(opts?: Object): void;
		assertConditionalExpression(opts?: Object): void;
		assertContinueStatement(opts?: Object): void;
		assertDebuggerStatement(opts?: Object): void;
		assertDoWhileStatement(opts?: Object): void;
		assertEmptyStatement(opts?: Object): void;
		assertExpressionStatement(opts?: Object): void;
		assertFile(opts?: Object): void;
		assertForInStatement(opts?: Object): void;
		assertForStatement(opts?: Object): void;
		assertFunctionDeclaration(opts?: Object): void;
		assertFunctionExpression(opts?: Object): void;
		assertIdentifier(opts?: Object): void;
		assertIfStatement(opts?: Object): void;
		assertLabeledStatement(opts?: Object): void;
		assertStringLiteral(opts?: Object): void;
		assertNumericLiteral(opts?: Object): void;
		assertNullLiteral(opts?: Object): void;
		assertBooleanLiteral(opts?: Object): void;
		assertRegExpLiteral(opts?: Object): void;
		assertLogicalExpression(opts?: Object): void;
		assertMemberExpression(opts?: Object): void;
		assertNewExpression(opts?: Object): void;
		assertProgram(opts?: Object): void;
		assertObjectExpression(opts?: Object): void;
		assertObjectMethod(opts?: Object): void;
		assertObjectProperty(opts?: Object): void;
		assertRestElement(opts?: Object): void;
		assertReturnStatement(opts?: Object): void;
		assertSequenceExpression(opts?: Object): void;
		assertSwitchCase(opts?: Object): void;
		assertSwitchStatement(opts?: Object): void;
		assertThisExpression(opts?: Object): void;
		assertThrowStatement(opts?: Object): void;
		assertTryStatement(opts?: Object): void;
		assertUnaryExpression(opts?: Object): void;
		assertUpdateExpression(opts?: Object): void;
		assertVariableDeclaration(opts?: Object): void;
		assertVariableDeclarator(opts?: Object): void;
		assertWhileStatement(opts?: Object): void;
		assertWithStatement(opts?: Object): void;
		assertAssignmentPattern(opts?: Object): void;
		assertArrayPattern(opts?: Object): void;
		assertArrowFunctionExpression(opts?: Object): void;
		assertClassBody(opts?: Object): void;
		assertClassDeclaration(opts?: Object): void;
		assertClassExpression(opts?: Object): void;
		assertExportAllDeclaration(opts?: Object): void;
		assertExportDefaultDeclaration(opts?: Object): void;
		assertExportNamedDeclaration(opts?: Object): void;
		assertExportSpecifier(opts?: Object): void;
		assertForOfStatement(opts?: Object): void;
		assertImportDeclaration(opts?: Object): void;
		assertImportDefaultSpecifier(opts?: Object): void;
		assertImportNamespaceSpecifier(opts?: Object): void;
		assertImportSpecifier(opts?: Object): void;
		assertMetaProperty(opts?: Object): void;
		assertClassMethod(opts?: Object): void;
		assertObjectPattern(opts?: Object): void;
		assertSpreadElement(opts?: Object): void;
		assertSuper(opts?: Object): void;
		assertTaggedTemplateExpression(opts?: Object): void;
		assertTemplateElement(opts?: Object): void;
		assertTemplateLiteral(opts?: Object): void;
		assertYieldExpression(opts?: Object): void;
		assertAnyTypeAnnotation(opts?: Object): void;
		assertArrayTypeAnnotation(opts?: Object): void;
		assertBooleanTypeAnnotation(opts?: Object): void;
		assertBooleanLiteralTypeAnnotation(opts?: Object): void;
		assertNullLiteralTypeAnnotation(opts?: Object): void;
		assertClassImplements(opts?: Object): void;
		assertClassProperty(opts?: Object): void;
		assertDeclareClass(opts?: Object): void;
		assertDeclareFunction(opts?: Object): void;
		assertDeclareInterface(opts?: Object): void;
		assertDeclareModule(opts?: Object): void;
		assertDeclareTypeAlias(opts?: Object): void;
		assertDeclareVariable(opts?: Object): void;
		assertExistentialTypeParam(opts?: Object): void;
		assertFunctionTypeAnnotation(opts?: Object): void;
		assertFunctionTypeParam(opts?: Object): void;
		assertGenericTypeAnnotation(opts?: Object): void;
		assertInterfaceExtends(opts?: Object): void;
		assertInterfaceDeclaration(opts?: Object): void;
		assertIntersectionTypeAnnotation(opts?: Object): void;
		assertMixedTypeAnnotation(opts?: Object): void;
		assertNullableTypeAnnotation(opts?: Object): void;
		assertNumericLiteralTypeAnnotation(opts?: Object): void;
		assertNumberTypeAnnotation(opts?: Object): void;
		assertStringLiteralTypeAnnotation(opts?: Object): void;
		assertStringTypeAnnotation(opts?: Object): void;
		assertThisTypeAnnotation(opts?: Object): void;
		assertTupleTypeAnnotation(opts?: Object): void;
		assertTypeofTypeAnnotation(opts?: Object): void;
		assertTypeAlias(opts?: Object): void;
		assertTypeAnnotation(opts?: Object): void;
		assertTypeCastExpression(opts?: Object): void;
		assertTypeParameterDeclaration(opts?: Object): void;
		assertTypeParameterInstantiation(opts?: Object): void;
		assertObjectTypeAnnotation(opts?: Object): void;
		assertObjectTypeCallProperty(opts?: Object): void;
		assertObjectTypeIndexer(opts?: Object): void;
		assertObjectTypeProperty(opts?: Object): void;
		assertQualifiedTypeIdentifier(opts?: Object): void;
		assertUnionTypeAnnotation(opts?: Object): void;
		assertVoidTypeAnnotation(opts?: Object): void;
		assertJSXAttribute(opts?: Object): void;
		assertJSXClosingElement(opts?: Object): void;
		assertJSXElement(opts?: Object): void;
		assertJSXEmptyExpression(opts?: Object): void;
		assertJSXExpressionContainer(opts?: Object): void;
		assertJSXIdentifier(opts?: Object): void;
		assertJSXMemberExpression(opts?: Object): void;
		assertJSXNamespacedName(opts?: Object): void;
		assertJSXOpeningElement(opts?: Object): void;
		assertJSXSpreadAttribute(opts?: Object): void;
		assertJSXText(opts?: Object): void;
		assertNoop(opts?: Object): void;
		assertParenthesizedExpression(opts?: Object): void;
		assertAwaitExpression(opts?: Object): void;
		assertBindExpression(opts?: Object): void;
		assertDecorator(opts?: Object): void;
		assertDoExpression(opts?: Object): void;
		assertExportDefaultSpecifier(opts?: Object): void;
		assertExportNamespaceSpecifier(opts?: Object): void;
		assertRestProperty(opts?: Object): void;
		assertSpreadProperty(opts?: Object): void;
		assertExpression(opts?: Object): void;
		assertBinary(opts?: Object): void;
		assertScopable(opts?: Object): void;
		assertBlockParent(opts?: Object): void;
		assertBlock(opts?: Object): void;
		assertStatement(opts?: Object): void;
		assertTerminatorless(opts?: Object): void;
		assertCompletionStatement(opts?: Object): void;
		assertConditional(opts?: Object): void;
		assertLoop(opts?: Object): void;
		assertWhile(opts?: Object): void;
		assertExpressionWrapper(opts?: Object): void;
		assertFor(opts?: Object): void;
		assertForXStatement(opts?: Object): void;
		assertFunction(opts?: Object): void;
		assertFunctionParent(opts?: Object): void;
		assertPureish(opts?: Object): void;
		assertDeclaration(opts?: Object): void;
		assertLVal(opts?: Object): void;
		assertLiteral(opts?: Object): void;
		assertImmutable(opts?: Object): void;
		assertUserWhitespacable(opts?: Object): void;
		assertMethod(opts?: Object): void;
		assertObjectMember(opts?: Object): void;
		assertProperty(opts?: Object): void;
		assertUnaryLike(opts?: Object): void;
		assertPattern(opts?: Object): void;
		assertClass(opts?: Object): void;
		assertModuleDeclaration(opts?: Object): void;
		assertExportDeclaration(opts?: Object): void;
		assertModuleSpecifier(opts?: Object): void;
		assertFlow(opts?: Object): void;
		assertFlowBaseAnnotation(opts?: Object): void;
		assertFlowDeclaration(opts?: Object): void;
		assertJSX(opts?: Object): void;
		assertNumberLiteral(opts?: Object): void;
		assertRegexLiteral(opts?: Object): void;
		}

		interface TraversalContext {
		parentPath: NodePath<Node>;
		scope: Scope;
		state: any;
		opts: any;
		}
		export class Hub {
		constructor(file: any, options: any);
		file: any;
		options: any;
		}

		interface TraversalContext {
		parentPath: NodePath<Node>;
		scope: Scope;
		state: any;
		opts: any;
		}

package.json

		{
		"name": "@types/babel-traverse",
		"version": "6.7.8-alpha",
		"version": "6.7.9-alpha",
		"description": "TypeScript definitions for babel-traverse v6.7",
		@@ -8,7 +8,11 @@ "main": "",
		"author": "Troy Gerwien <https://github.com/yortus>",
		"repository": {
		"type": "git",
		"url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git"
		},
		"license": "MIT",
		"typings": "index.d.ts",
		"dependencies": {
		"@types/babel-types": "*"
		"@types/babel-types": "6.7.8-alpha"
		}
		}

README.md

		@@ -11,6 +11,6 @@ # Installation
		Additional Details
		* Last updated: Wed, 25 May 2016 04:19:59 GMT
		* File structure: DeclareModule
		* Last updated: Fri, 01 Jul 2016 22:02:52 GMT
		* File structure: ProperModule
		* Library Dependencies: babel-types
		* Module Dependencies: none
		* Module Dependencies: babel-types
		* Global values: none
		@@ -17,0 +17,0 @@

types-metadata.json

		@@ -7,3 +7,5 @@ {
		],
		"moduleDependencies": [],
		"moduleDependencies": [
		"babel-types"
		],
		"libraryMajorVersion": "6",
		@@ -16,3 +18,3 @@ "libraryMinorVersion": "7",
		"sourceBranch": "types-2.0",
		"kind": "DeclareModule",
		"kind": "ProperModule",
		"globals": [],
		@@ -25,3 +27,3 @@ "declaredModules": [
		],
		"contentHash": "38eec27207db30e64162b029041e84fbb76bd5bf0f08b0a4b1ce46c76390df02"
		"contentHash": "72b733f8f05874e4cf66e164a43b17d562f9639307f7cce356db40debadad26c"
		}

@types/babel-traverse - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics

Dependency changes