eslint-plugin-mocha/ast/node-types.d.ts

Eslint rules for mocha.

import type { Rule } from 'eslint';
import type { Except } from 'type-fest';
type NodeType<T extends keyof Rule.NodeListener> = Parameters<Exclude<Rule.NodeListener[T], undefined>>[0];
export type MemberExpression = NodeType<'MemberExpression'>;
export declare function isMemberExpression(node: Except<Rule.Node, 'parent'>): node is MemberExpression;
export declare function expectMemberExpression(node: Readonly<Rule.Node>): MemberExpression;
export type CallExpression = NodeType<'CallExpression'>;
export declare function isCallExpression(node: Except<Rule.Node, 'parent'>): node is CallExpression;
export declare function expectCallExpression(node: Readonly<Rule.Node>): CallExpression;
export type BlockStatement = NodeType<'BlockStatement'>;
export declare function isBlockStatement(node: Except<Rule.Node, 'parent'>): node is BlockStatement;
export type ReturnStatement = NodeType<'ReturnStatement'>;
export declare function isReturnStatement(node: Except<Rule.Node, 'parent'>): node is ReturnStatement;
export type Identifier = NodeType<'Identifier'>;
export declare function isIdentifier(node: Except<Rule.Node, 'parent'>): node is Identifier;
export type VariableDeclarator = NodeType<'VariableDeclarator'>;
export declare function isVariableDeclarator(node: Rule.Node): node is VariableDeclarator;
export type Pattern = Readonly<VariableDeclarator['id']>;
export type ObjectPattern = Extract<Pattern, {
    readonly type: 'ObjectPattern';
}>;
export type IdentifierPattern = Extract<Pattern, {
    readonly type: 'Identifier';
}>;
export declare function isObjectPattern(pattern: Pattern): pattern is ObjectPattern;
export declare function isIdentifierPattern(pattern: Pattern): pattern is IdentifierPattern;
export type AssignmentProperty = Extract<ObjectPattern['properties'][number], {
    readonly type: 'Property';
}>;
export declare function isAssignmentProperty(property: ObjectPattern['properties'][number]): property is AssignmentProperty;
type FunctionExpression = NodeType<'FunctionExpression'>;
type FunctionDeclaration = NodeType<'FunctionDeclaration'>;
export type ArrowFunctionExpression = NodeType<'ArrowFunctionExpression'>;
export declare function isArrowFunctionExpression(node: Except<Rule.Node, 'parent'>): node is ArrowFunctionExpression;
export type AnyFunction = ArrowFunctionExpression | FunctionDeclaration | FunctionExpression;
export declare function isFunction(node: Except<Rule.Node, 'parent'>): node is AnyFunction;
export type Literal = NodeType<'Literal'>;
export declare function isLiteral(node: Except<Rule.Node, 'parent'>): node is Literal;
export type Program = NodeType<'Program'>;
export declare function isProgram(node: Except<Rule.Node, 'parent'>): node is Program;
export declare function getParentNode(node: Rule.Node): Rule.Node;
export {};
//# sourceMappingURL=node-types.d.ts.map