import { Token } from '../keywords/index.js';

type NodeType = "Program" | "Literal" | "Property" | "CommentStatement" | "EmptyLine" | "LambdaFunctionDecl" | "FunctionDeclaration" | "VariableDeclaration" | "UseDeclaration" | "UseSpecifier" | "UseDefaultSpecifier" | "TemplateElement" | "BinaryExpression" | "ArrayExpression" | "ObjectExpression" | "MemberExpression" | "CallExpression" | "AssignmentExpression" | "CompareExpression" | "EqualExpression" | "TernayExpression" | "RangeExpression" | "IterableExpression" | "ToExpression" | "TemplateLiteralExpression" | "RunStatement" | "WaitStatement" | "TaskStatement" | "BlockStatement" | "ReturnStatement" | "ExpressionStatement" | "IfStatement" | "ForStatement" | "SwitchStmtement" | "CaseBlockStatement" | "DefaultCaseBlockStatement" | "ExposeStmtement";
interface Node {
    type: NodeType;
    id?: UnitNodeInstance<Literal> | Token;
}
interface Expr extends Node {
}
type UnitNodeInstance<T extends unknown> = T & {
    origin: T;
    parent: UnitNodeInstance<BlockStmt> | null;
    findBlock: () => UnitNodeInstance<BlockStmt> | null;
};
interface Literal extends Expr {
    value: Token;
    type: "Literal";
}
interface Property extends Node {
    key: UnitNodeInstance<Literal>;
    value: UnitNodeInstance<Expr>;
    type: "Property";
}
interface TemplateElement extends Node {
    value: UnitNodeInstance<Literal>;
    type: "TemplateElement";
}
interface EmptyLineStmt extends Node {
    type: "EmptyLine";
}
interface UseSpecifier extends Node {
    remote: UnitNodeInstance<Literal>;
    local: UnitNodeInstance<Literal>;
    type: "UseSpecifier";
}
interface UseDefaultSpecifier extends Node {
    local: UnitNodeInstance<Literal>;
    type: "UseDefaultSpecifier";
}
interface UseDecl extends Node {
    type: "UseDeclaration";
    source: UnitNodeInstance<Literal>;
    specifiers: (UseSpecifier | UseDefaultSpecifier)[];
}
interface FunctionDecl extends Node {
    preId: Token;
    id: UnitNodeInstance<Literal>;
    arguments: UnitNodeInstance<Expr>[];
    body: UnitNodeInstance<BlockStmt>;
    type: "FunctionDeclaration";
}
interface LambdaFunctionDecl extends Node {
    arguments: UnitNodeInstance<Expr>[];
    body: UnitNodeInstance<BlockStmt>;
    type: "LambdaFunctionDecl";
}
interface VariableDecl extends Node {
    preId: Token;
    id: UnitNodeInstance<Literal>;
    value: UnitNodeInstance<Expr>;
    type: "VariableDeclaration";
    is_const: boolean;
}
interface RangeExpr extends Expr {
    start: UnitNodeInstance<Expr>;
    end: UnitNodeInstance<Expr>;
    step: Token;
    type: "RangeExpression";
}
interface EqualExpr extends Expr {
    left: UnitNodeInstance<Expr>;
    right: UnitNodeInstance<Expr>;
    operator: Token;
    type: "EqualExpression";
}
interface CompareExpr extends Expr {
    left: UnitNodeInstance<Expr>;
    right: UnitNodeInstance<Expr>;
    operator: Token;
    type: "CompareExpression";
}
interface CallExpr extends Expr {
    callee: UnitNodeInstance<Literal>;
    arguments: UnitNodeInstance<Expr>[];
    type: "CallExpression";
}
interface TernaryExpr extends Expr {
    condition: UnitNodeInstance<Expr>;
    consequent: UnitNodeInstance<Expr>;
    alternate: UnitNodeInstance<Expr>;
    type: "TernayExpression";
}
interface ObjectExpr extends Node {
    properties: UnitNodeInstance<Property>[];
    type: "ObjectExpression";
}
interface ArrayExpr extends Node {
    items: UnitNodeInstance<Property>[];
    type: "ArrayExpression";
}
interface MemberExpr extends Expr {
    object: UnitNodeInstance<Expr>;
    property: UnitNodeInstance<Expr> | UnitNodeInstance<Expr>[];
    type: "MemberExpression";
    computed: boolean;
}
interface AssignmentExpr extends Expr {
    left: UnitNodeInstance<Literal>;
    right: UnitNodeInstance<Expr>;
    operator: Token;
    type: "AssignmentExpression";
}
interface AssignmentExpr extends Expr {
    left: UnitNodeInstance<Literal>;
    right: UnitNodeInstance<Expr>;
    operator: Token;
    type: "AssignmentExpression";
}
interface BinaryExpr extends Expr {
    left: UnitNodeInstance<Expr>;
    right: UnitNodeInstance<Expr>;
    operator: Token;
}
interface ToExpr extends Expr {
    body: UnitNodeInstance<BlockStmt>;
    arguments: UnitNodeInstance<Expr>[];
    type: "ToExpression";
}
interface TemplateLiteralExpr extends Expr {
    type: "TemplateLiteralExpression";
    quotes: UnitNodeInstance<TemplateElement | Expr>[];
}
interface CommentStmt extends Node {
    value: Token;
    type: "CommentStatement";
}
interface RunStmt extends Expr {
    callee: UnitNodeInstance<CallExpr>;
    to: UnitNodeInstance<ToExpr>[];
    type: "RunStatement";
}
interface ExposeStmt extends Node {
    id: Token;
    body: UnitNodeInstance<Expr>;
    specifiers: UnitNodeInstance<Expr>[];
    type: "ExposeStmtement";
}
interface BlockStmt extends Node {
    body: UnitNodeInstance<Expr>[];
    type: "BlockStatement";
}
interface CaseBlockStmt extends Node {
    body: UnitNodeInstance<BlockStmt>;
    test: UnitNodeInstance<Expr>;
    type: "CaseBlockStatement";
}
interface DefaultCaseBlockStmt extends Node {
    body: UnitNodeInstance<BlockStmt>;
    test: UnitNodeInstance<Expr>;
    type: "DefaultCaseBlockStatement";
}
interface ReturnStmt extends Node {
    value: UnitNodeInstance<Expr>;
    type: "ReturnStatement";
}
interface ProgramStmt extends Node {
    body: UnitNodeInstance<Expr>[];
    type: "Program";
}
interface IfStmt extends Node {
    test: UnitNodeInstance<Expr>;
    consequent: UnitNodeInstance<BlockStmt>;
    alternate?: UnitNodeInstance<BlockStmt>;
    type: "IfStatement";
}
interface ForStmt extends Node {
    init: UnitNodeInstance<Expr>;
    value?: UnitNodeInstance<Expr>;
    range: UnitNodeInstance<RangeExpr>;
    update: UnitNodeInstance<Expr>;
    body: UnitNodeInstance<BlockStmt>;
    type: "ForStatement";
}
interface SwitchStmt extends Node {
    test: UnitNodeInstance<Expr>;
    cases: UnitNodeInstance<DefaultCaseBlockStmt | CaseBlockStmt>[];
    type: "SwitchStmtement";
}
interface ExpressionStmt extends Node {
    expression: UnitNodeInstance<Expr>;
    type: "ExpressionStatement";
}
interface TaskStmt extends Node {
    fn: UnitNodeInstance<FunctionDecl>;
    type: "TaskStatement";
}
interface WaitStmt extends Node {
    type: "WaitStatement";
    async: UnitNodeInstance<RunStmt>;
}

export type { ArrayExpr, AssignmentExpr, BinaryExpr, BlockStmt, CallExpr, CaseBlockStmt, CommentStmt, CompareExpr, DefaultCaseBlockStmt, EmptyLineStmt, EqualExpr, ExposeStmt, Expr, ExpressionStmt, ForStmt, FunctionDecl, IfStmt, LambdaFunctionDecl, Literal, MemberExpr, Node, NodeType, ObjectExpr, ProgramStmt, Property, RangeExpr, ReturnStmt, RunStmt, SwitchStmt, TaskStmt, TemplateElement, TemplateLiteralExpr, TernaryExpr, ToExpr, UnitNodeInstance, UseDecl, UseDefaultSpecifier, UseSpecifier, VariableDecl, WaitStmt };