export interface Node {
    type: string;
    loc?: SourceLocation | null;
}
export interface SourceLocation {
    source?: string | null;
    start: Position;
    end: Position;
}
export interface Position {
    line: number;
    column: number;
}
export declare type SourceType = 'module' | 'script';
export declare type Parameter = AssignmentPattern | ArrayPattern | ObjectPattern | Identifier;
export interface Program extends Node {
    type: 'Program';
    sourceType: SourceType;
    body: Statement[];
    start?: number;
    end?: number;
    range?: [number, number];
}
export declare type Pattern = Identifier | ObjectPattern | ArrayPattern | AssignmentPattern | MemberExpression;
export declare type BindingPattern = ArrayPattern | ObjectPattern | Identifier;
export interface ArrayPattern extends Node {
    type: 'ArrayPattern';
    elements: Expression[];
}
export interface ObjectPattern extends Node {
    type: 'ObjectPattern';
    properties: ObjectLiteralElementLike[];
}
export declare type ObjectLiteralElementLike = Property;
export interface Identifier extends Expression {
    type: 'Identifier';
    name: string;
}
export interface Literal extends Expression {
    type: 'Literal';
    value: string | boolean | null | number | RegExp;
}
export interface Class extends Node {
    id: Identifier | null;
    superClass: Expression | null;
    body: ClassBody;
}
export interface ClassBody extends Node {
    type: 'ClassBody';
    body: MethodDefinition[];
}
export interface MethodDefinition extends Node {
    type: 'MethodDefinition';
    key: Expression;
    value: FunctionExpression;
    kind: 'constructor' | 'method' | 'get' | 'set';
    computed: boolean;
    static: boolean;
}
export interface Function extends Node {
    id: Identifier | null;
    params: Pattern[];
    body: FunctionBody;
}
export declare type Statement = BlockStatement | ExpressionStatement | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | VariableDeclaration | FunctionDeclaration | ClassDeclaration | IterationStatement;
export declare type IterationStatement = ForStatement | ForInStatement | ForOfStatement | WhileStatement | DoWhileStatement;
export interface Directive extends Node {
    type: 'ExpressionStatement';
    expression: Literal;
    directive: string;
}
export interface BlockStatement extends Node {
    type: 'BlockStatement';
    body: Statement[];
}
export interface ExpressionStatement extends Node {
    type: 'ExpressionStatement';
    expression: Expression;
}
export interface FunctionBody extends Node {
    body: Directive | Statement[];
}
export interface EmptyStatement extends Node {
    type: 'EmptyStatement';
}
export interface DebuggerStatement extends Node {
    type: 'DebuggerStatement';
}
export interface WithStatement extends Node {
    type: 'WithStatement';
    object: Expression;
    body: Statement;
}
export interface ReturnStatement extends Node {
    type: 'ReturnStatement';
    argument: Expression | null;
}
export interface LabeledStatement extends Node {
    type: 'LabeledStatement';
    label: Identifier;
    body: Statement;
}
export interface BreakStatement extends Node {
    type: 'BreakStatement';
    label: Identifier | null;
}
export interface ContinueStatement extends Node {
    type: 'ContinueStatement';
    label: Identifier | null;
}
export interface IfStatement extends Node {
    type: 'IfStatement';
    test: Expression;
    consequent: Statement;
    alternate: Statement | null;
}
export interface SwitchStatement extends Node {
    type: 'SwitchStatement';
    discriminant: Expression;
    cases: SwitchCase[];
}
export interface SwitchCase extends Node {
    type: 'SwitchCase';
    test: Expression | null;
    consequent: Statement[];
}
export interface ThrowStatement extends Node {
    type: 'ThrowStatement';
    argument: Expression;
}
export interface TryStatement extends Node {
    type: 'TryStatement';
    block: BlockStatement;
    handler: CatchClause | null;
    finalizer: BlockStatement | null;
}
export interface CatchClause extends Node {
    type: 'CatchClause';
    param: Pattern | null;
    body: BlockStatement;
}
export interface WhileStatement extends Node {
    type: 'WhileStatement';
    test: Expression;
    body: Statement;
}
export interface DoWhileStatement extends Node {
    type: 'DoWhileStatement';
    test: Expression;
    body: Statement;
}
export interface ForStatement extends Node {
    type: 'ForStatement';
    init: VariableDeclaration | Expression | null;
    test: Expression | null;
    update: Expression | null;
    body: Statement;
}
export interface ForInStatement extends Node {
    type: 'ForInStatement';
    left: VariableDeclaration | Expression;
    right: Expression;
    body: Statement;
}
export interface ForOfStatement extends Node {
    type: 'ForOfStatement';
    left: VariableDeclaration | Expression;
    right: Expression;
    body: Statement;
    await: boolean;
}
export interface ClassDeclaration extends Class {
    type: 'ClassDeclaration';
    id: Identifier;
}
export interface FunctionDeclaration extends Function {
    type: 'FunctionDeclaration';
}
export interface VariableDeclaration extends Node {
    type: 'VariableDeclaration';
    declarations: VariableDeclarator[];
    kind: 'let' | 'const' | 'var';
}
export interface VariableDeclarator extends Node {
    type: 'VariableDeclarator';
    id: Pattern;
    init: Expression | null;
}
export declare type Expression = any;
export declare type LeftHandSideExpression = AssignmentExpression | ConditionalExpression | MemberExpression | BinaryExpression | CallExpression | UnaryExpression | NewExpression | ThisExpression | FunctionExpression | FunctionBody | ImportMeta;
export interface ThisExpression extends Node {
    type: 'ThisExpression';
}
export interface ArrayExpression extends Node {
    type: 'ArrayExpression';
    elements: any[];
}
export interface ObjectExpression extends Node {
    type: 'ObjectExpression';
    properties: Property[];
}
export interface Property extends Node {
    type: 'Property';
    key: Expression;
    value: Expression;
    computed: boolean;
    method: boolean;
    shorthand: boolean;
    kind: 'init' | 'get' | 'set';
}
export interface ClassExpression extends Class, Expression {
    type: 'ClassExpression';
}
export interface FunctionExpression extends Function, Expression {
    type: 'FunctionExpression';
}
export interface UnaryExpression extends Node {
    type: 'UnaryExpression';
    operator: UnaryOperator;
    prefix: true;
    argument: Expression;
}
export declare type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';
export interface UpdateExpression extends Node {
    type: 'UpdateExpression';
    operator: UpdateOperator;
    argument: Expression;
    prefix: boolean;
}
export declare type UpdateOperator = '++' | '--';
export interface BinaryExpression extends Node {
    type: 'BinaryExpression';
    operator: BinaryOperator;
    left: Expression;
    right: Expression;
}
export declare type BinaryOperator = '==' | '!=' | '===' | '!==' | '<' | '<=' | '>' | '>=' | '<<' | '>>' | '>>>' | '+' | '-' | '*' | '/' | '%' | '|' | '^' | '&' | 'in' | 'instanceof';
export interface AssignmentExpression extends Node {
    type: 'AssignmentExpression';
    operator: AssignmentOperator;
    left: Expression;
    right: Expression;
}
export interface AssignmentPattern extends Node {
    type: 'AssignmentPattern';
    left: BindingPattern | Identifier;
    right?: Expression;
}
export declare type AssignmentOperator = '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '<<=' | '>>=' | '>>>=' | '|=' | '^=' | '&=';
export interface LogicalExpression extends Node {
    type: 'LogicalExpression';
    operator: LogicalOperator;
    left: Expression;
    right: Expression;
}
export declare type LogicalOperator = '||' | '&&';
export interface MemberExpression extends Node {
    type: 'MemberExpression';
    object: Expression;
    property: Expression;
    computed?: boolean;
}
export interface ConditionalExpression extends Node {
    type: 'ConditionalExpression';
    test: Expression;
    consequent: Expression;
    alternate: Expression;
}
export interface CallExpression extends Node {
    type: 'CallExpression';
    callee: Expression;
    arguments: Expression[];
}
export interface NewExpression extends Node {
    type: 'NewExpression';
    callee: Expression;
    arguments: Expression[];
}
export interface SequenceExpression extends Node {
    type: 'SequenceExpression';
    expressions: Expression[];
}
//# sourceMappingURL=index.d.ts.map