@maniascript/parser/dist/lib/ast.d.ts

Maniascript parser

import { type Token } from 'antlr4ng';
import { ProgramContext, ProgramContentContext, RequireContextDirectiveContext, ExtendsDirectiveContext, IncludeDirectiveContext, SettingDirectiveContext, CommandDirectiveContext, StructDirectiveContext, StructDeclarationContext, StructMemberContext, StructAliasingContext, ConstDirectiveContext, ConstDeclarationContext, ConstAliasingContext, ArrayTypeContext, SimpleTypeContext, EnumTypeContext, CustomTypeContext, TextLiteralContext, LiteralContext, IntegerContext, RealContext, BooleanContext, EnumContext, VectorContext, ArrayContext, ArrayExpressionContext, StructureContext, StructureMemberInitializationContext, FunctionCallExpressionContext, FunctionCallContext, FunctionDeclarationContext, LabelDeclarationContext, BlockContext, ParameterContext, MainStatementContext, ExpressionStatementContext, AsExpressionContext, IsExpressionContext, DotAccessExpressionContext, IndexAccessExpressionContext, UnaryMinusExpressionContext, NotExpressionContext, MultiplicativeExpressionContext, AdditiveExpressionContext, ConcatenationExpressionContext, RelationalExpressionContext, EqualityExpressionContext, OrExpressionContext, AndExpressionContext, TextInterpolationExpressionContext, DumptypeExpressionContext, DumpExpressionContext, CastExpressionContext, ThisExpressionContext, NowExpressionContext, AssignmentStatementContext, ReturnStatementContext, LabelStatementContext, AssertStatementContext, ForeachStatementContext, ForStatementContext, WhileStatementContext, MeanwhileStatementContext, BreakStatementContext, ContinueStatementContext, SwitchStatementContext, SwitchCaseContext, SwitchDefaultContext, SwitchtypeStatementContext, SwitchtypeCaseContext, SwitchtypeDefaultContext, ConditionalStatementContext, IfBranchContext, ElseIfBranchContext, ElseBranchContext, LogStatementContext, SleepStatementContext, TuningstartStatementContext, TuningendStatementContext, TuningmarkStatementContext, WaitStatementContext, YieldStatementContext, StructureExpressionContext, VariableDeclarationWithTypeContext, VariableDeclarationWithoutTypeContext, VariableDeclarationLetContext } from '../antlr/ManiaScriptParser.js';
import { SourceLocationRange } from './position.js';
interface AST {
    program?: Program;
}
type VisitCallback = ((node: Node) => void) | null;
declare enum Kind {
    Program = "Program",
    SimpleType = "SimpleType",
    ClassType = "ClassType",
    EnumType = "EnumType",
    CustomType = "CustomType",
    InvalidType = "InvalidType",
    ArrayType = "ArrayType",
    InvalidLiteral = "InvalidLiteral",
    TextLiteral = "TextLiteral",
    IntegerLiteral = "IntegerLiteral",
    RealLiteral = "RealLiteral",
    BooleanLiteral = "BooleanLiteral",
    NullLiteral = "NullLiteral",
    NullIdLiteral = "NullIdLiteral",
    EnumLiteral = "EnumLiteral",
    Identifier = "Identifier",
    InvalidIdentifier = "InvalidIdentifier",
    RequireContextDirective = "RequireContextDirective",
    InvalidDirective = "InvalidDirective",
    ExtendsDirective = "ExtendsDirective",
    IncludeDirective = "IncludeDirective",
    InvalidSettingValue = "InvalidSettingValue",
    SettingDirective = "SettingDirective",
    CommandDirective = "CommandDirective",
    StructMemberDeclaration = "StructMemberDeclaration",
    StructDeclaration = "StructDeclaration",
    StructAliasing = "StructAliasing",
    StructDirective = "StructDirective",
    InvalidConstValue = "InvalidConstValue",
    ConstDeclaration = "ConstDeclaration",
    ConstAliasing = "ConstAliasing",
    ConstDirective = "ConstDirective",
    InvalidDeclaration = "InvalidDeclaration",
    VariableDeclaration = "VariableDeclaration",
    FunctionParameterDeclaration = "FunctionParameterDeclaration",
    FunctionDeclaration = "FunctionDeclaration",
    LabelDeclaration = "LabelDeclaration",
    BlockStatement = "BlockStatement",
    InvalidStatement = "InvalidStatement",
    ExpressionStatement = "ExpressionStatement",
    InvalidExpression = "InvalidExpression",
    VectorExpression = "VectorExpression",
    ArrayExpression = "ArrayExpression",
    StructMemberExpression = "StructMemberExpression",
    StructExpression = "StructExpression",
    FunctionCallExpression = "FunctionCallExpression",
    AsExpression = "AsExpression",
    IsExpression = "IsExpression",
    DotAccessExpression = "DotAccessExpression",
    IndexAccessExpression = "IndexAccessExpression",
    UnaryExpression = "UnaryExpression",
    BinaryExpression = "BinaryExpression",
    LogicalExpression = "LogicalExpression",
    TemplateTextLiteral = "TemplateTextLiteral",
    TemplateTextElement = "TemplateTextElement",
    DumptypeExpression = "DumptypeExpression",
    DumpExpression = "DumpExpression",
    CastExpression = "CastExpression",
    ThisExpression = "ThisExpression",
    NowExpression = "NowExpression",
    AssignmentStatement = "AssignmentStatement",
    ReturnStatement = "ReturnStatement",
    LabelStatement = "LabelStatement",
    AssertStatement = "AssertStatement",
    ForeachStatement = "ForeachStatement",
    ForStatement = "ForStatement",
    WhileStatement = "WhileStatement",
    MeanwhileStatement = "MeanwhileStatement",
    BreakStatement = "BreakStatement",
    ContinueStatement = "ContinueStatement",
    SwitchStatement = "SwitchStatement",
    SwitchCase = "SwitchCase",
    SwitchtypeStatement = "SwitchtypeStatement",
    SwitchtypeCase = "SwitchtypeCase",
    ConditionalStatement = "ConditionalStatement",
    ConditionalBranch = "ConditionalBranch",
    LogStatement = "LogStatement",
    SleepStatement = "SleepStatement",
    TuningstartStatement = "TuningstartStatement",
    TuningendStatement = "TuningendStatement",
    TuningmarkStatement = "TuningmarkStatement",
    WaitStatement = "WaitStatement",
    YieldStatement = "YieldStatement",
    Main = "Main"
}
declare abstract class Node {
    abstract kind: Kind;
    source: SourceLocationRange;
    parent?: Node;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null);
    enter(enterCb: VisitCallback): void;
    exit(exitCb: VisitCallback): void;
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class Program extends Node {
    kind: Kind;
    directives: Directive[];
    declarations: Declaration[];
    main?: Main;
    constructor(program: ProgramContentContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare enum TypeName {
    Boolean = "Boolean",
    Ident = "Ident",
    Int2 = "Int2",
    Int3 = "Int3",
    Integer = "Integer",
    Real = "Real",
    Text = "Text",
    Vec2 = "Vec2",
    Vec3 = "Vec3",
    Void = "Void",
    Invalid = "Invalid"
}
type BaseType = (SimpleType | ClassType | EnumType | CustomType | InvalidType);
declare function isBaseType(node: Node): node is BaseType;
type KeyType = (BaseType | 'EmptyKey');
type InitializerType = (SimpleType | ClassType | ArrayType | InvalidType);
declare function isInitializerType(node: Node): node is InitializerType;
type Type = (BaseType | ArrayType);
declare function isType(node: Node): node is Type;
declare class SimpleType extends Node {
    kind: Kind;
    name: TypeName;
    constructor(parent: Node, simpleType: SimpleTypeContext);
}
declare class ClassType extends Node {
    kind: Kind;
    name: string;
    constructor(parent: Node, className: Token);
}
declare class EnumType extends Node {
    kind: Kind;
    class?: ClassType;
    name: Identifier;
    constructor(parent: Node, enumType: EnumTypeContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class CustomType extends Node {
    kind: Kind;
    name: Identifier;
    constructor(parent: Node, customType: CustomTypeContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class InvalidType extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class ArrayType extends Node {
    kind: Kind;
    value: BaseType;
    keys: KeyType[];
    constructor(parent: Node, arrayType: ArrayTypeContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
type Literal = (TextLiteral | IntegerLiteral | RealLiteral | BooleanLiteral | NullLiteral | NullIdLiteral | EnumLiteral | InvalidLiteral);
declare function isLiteral(node: Node): node is Literal;
declare class InvalidLiteral extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class TextLiteral extends Node {
    kind: Kind;
    isTranslated: boolean;
    isMultiline: boolean;
    value: string;
    raw: string;
    constructor(parent: Node, textLiteral: TextLiteralContext);
}
declare class IntegerLiteral extends Node {
    kind: Kind;
    value: number;
    raw: string;
    constructor(parent: Node, integerLiteral: IntegerContext);
}
declare class RealLiteral extends Node {
    kind: Kind;
    value: number;
    raw: string;
    constructor(parent: Node, realLiteral: RealContext);
}
declare class BooleanLiteral extends Node {
    kind: Kind;
    value: boolean;
    constructor(parent: Node, booleanLiteral: BooleanContext);
}
declare class NullLiteral extends Node {
    kind: Kind;
    constructor(parent: Node, nullLiteral: LiteralContext);
}
declare class NullIdLiteral extends Node {
    kind: Kind;
    constructor(parent: Node, nullIdLiteral: LiteralContext);
}
declare class EnumLiteral extends Node {
    kind: Kind;
    class?: ClassType | Identifier;
    name: Identifier;
    value: Identifier;
    constructor(parent: Node, enumLiteral: EnumContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class Identifier extends Node {
    kind: Kind;
    namespace?: string;
    name: string;
    isExpression: boolean;
    constructor(parent: Node, identifier: Token, namespace?: Token | null, isExpression?: boolean);
}
declare class InvalidIdentifier extends Node {
    kind: Kind;
}
type Directive = (RequireContextDirective | ExtendsDirective | IncludeDirective | SettingDirective | CommandDirective | StructDirective | ConstDirective | InvalidDirective);
declare function isDirective(node: Node): node is Directive;
declare class InvalidDirective extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class RequireContextDirective extends Node {
    kind: Kind;
    class: ClassType;
    constructor(parent: Node, requireContextDirective: RequireContextDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ExtendsDirective extends Node {
    kind: Kind;
    path: TextLiteral;
    constructor(parent: Node, extendsDirective: ExtendsDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class IncludeDirective extends Node {
    kind: Kind;
    path: TextLiteral;
    alias?: Identifier;
    constructor(parent: Node, includeDirective: IncludeDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class InvalidSettingValue extends Node {
    kind: Kind;
}
declare class SettingDirective extends Node {
    kind: Kind;
    name: Identifier;
    value: Literal | VectorExpression | InvalidSettingValue;
    description?: TextLiteral;
    constructor(parent: Node, settingDirective: SettingDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class CommandDirective extends Node {
    kind: Kind;
    name: Identifier;
    type: Type;
    description?: TextLiteral;
    constructor(parent: Node, commandDirective: CommandDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructMemberDeclaration extends Node {
    kind: Kind;
    type: Type;
    name: Identifier;
    constructor(parent: Node, structMember: StructMemberContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructDeclaration extends Node {
    kind: Kind;
    name: Identifier;
    members: StructMemberDeclaration[];
    constructor(parent: Node, structDeclaration: StructDeclarationContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructAliasing extends Node {
    kind: Kind;
    name: Identifier;
    alias: Identifier;
    constructor(parent: Node, structAliasing: StructAliasingContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructDirective extends Node {
    kind: Kind;
    declaration?: StructDeclaration;
    aliasing?: StructAliasing;
    constructor(parent: Node, structDirective: StructDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class InvalidConstValue extends Node {
    kind: Kind;
}
declare class ConstDeclaration extends Node {
    kind: Kind;
    name: Identifier;
    value: Literal | VectorExpression | ArrayExpression | StructExpression | InvalidConstValue;
    constructor(parent: Node, constDeclaration: ConstDeclarationContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ConstAliasing extends Node {
    kind: Kind;
    name: Identifier;
    alias: Identifier;
    constructor(parent: Node, constAliasing: ConstAliasingContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ConstDirective extends Node {
    kind: Kind;
    declaration?: ConstDeclaration;
    aliasing?: ConstAliasing;
    constructor(parent: Node, constDirective: ConstDirectiveContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
type Declaration = (VariableDeclaration | FunctionDeclaration | LabelDeclaration | InvalidDeclaration);
declare function isDeclaration(node: Node): node is Declaration;
declare enum Storage {
    cloud = "cloud",
    metadata = "metadata",
    netread = "netread",
    netwrite = "netwrite",
    persistent = "persistent",
    invalid = "invalid"
}
declare enum InitializerSign {
    '=' = "=",
    '<=>' = "<=>",
    invalid = "invalid"
}
declare class InvalidDeclaration extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class VariableDeclaration extends Node {
    kind: Kind;
    isGlobal: boolean;
    isLet: boolean;
    storage?: Storage;
    type?: Type;
    name: Identifier;
    alias?: Identifier;
    forTarget?: Expression;
    initializerSign?: InitializerSign;
    initializerExpression?: Expression;
    initializerType?: InitializerType;
    constructor(parent: Node, variableDeclaration: VariableDeclarationWithTypeContext | VariableDeclarationWithoutTypeContext | VariableDeclarationLetContext, isGlobal: boolean);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class FunctionParameterDeclaration extends Node {
    kind: Kind;
    type: Type;
    name: Identifier;
    constructor(parent: Node, parameter: ParameterContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class FunctionDeclaration extends Node {
    kind: Kind;
    type: Type;
    name: Identifier;
    parameters: FunctionParameterDeclaration[];
    body: BlockStatement;
    constructor(parent: Node, functionDeclaration: FunctionDeclarationContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class LabelDeclaration extends Node {
    kind: Kind;
    name: Identifier;
    body: Statement[];
    constructor(parent: Node, labelDeclaration: LabelDeclarationContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
type Statement = (BlockStatement | InvalidStatement | VariableDeclaration | ExpressionStatement | AssignmentStatement | ReturnStatement | LabelStatement | AssertStatement | ForeachStatement | ForStatement | WhileStatement | MeanwhileStatement | BreakStatement | ContinueStatement | SwitchStatement | SwitchtypeStatement | ConditionalStatement | ConditionalBranch | LogStatement | SleepStatement | TuningstartStatement | TuningendStatement | TuningmarkStatement | WaitStatement | YieldStatement);
declare function isStatement(node: Node): node is Statement;
declare class BlockStatement extends Node {
    kind: Kind;
    body: Statement[];
    constructor(parent: Node, block: BlockContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class InvalidStatement extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class ExpressionStatement extends Node {
    kind: Kind;
    expression: Expression;
    constructor(parent: Node, expressionStatement: ExpressionStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare enum AssignmentOperator {
    '=' = "=",
    '<=>' = "<=>",
    '*=' = "*=",
    '/=' = "/=",
    '+=' = "+=",
    '-=' = "-=",
    '%=' = "%=",
    '^=' = "^="
}
declare class AssignmentStatement extends Node {
    kind: Kind;
    left: Expression;
    right: Expression | InitializerType;
    operator: AssignmentOperator;
    isInitializedByType: boolean;
    constructor(parent: Node, assignmentStatement: AssignmentStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ReturnStatement extends Node {
    kind: Kind;
    argument?: Expression | InitializerType;
    isReturningType: boolean;
    constructor(parent: Node, returnStatement: ReturnStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class LabelStatement extends Node {
    kind: Kind;
    isOverwrite: boolean;
    name: Identifier | InvalidIdentifier;
    constructor(parent: Node, labelStatement: LabelStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class AssertStatement extends Node {
    kind: Kind;
    test: Expression;
    message?: Expression;
    constructor(parent: Node, assertStatement: AssertStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ForeachStatement extends Node {
    kind: Kind;
    key?: Identifier;
    value: Identifier;
    expression: Expression;
    body: Statement;
    constructor(parent: Node, foreachStatement: ForeachStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ForStatement extends Node {
    kind: Kind;
    value: Identifier;
    loopStart: Expression;
    loopStop: Expression;
    increment?: Expression;
    body: Statement;
    constructor(parent: Node, forStatement: ForStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class WhileStatement extends Node {
    kind: Kind;
    test: Expression;
    body: Statement;
    constructor(parent: Node, whileStatement: WhileStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class MeanwhileStatement extends Node {
    kind: Kind;
    test: Expression;
    body: Statement;
    constructor(parent: Node, meanwhileStatement: MeanwhileStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class BreakStatement extends Node {
    kind: Kind;
    constructor(parent: Node, breakStatement: BreakStatementContext);
}
declare class ContinueStatement extends Node {
    kind: Kind;
    constructor(parent: Node, continueStatement: ContinueStatementContext);
}
declare class SwitchCase extends Node {
    kind: Kind;
    tests: Expression[];
    consequent: Statement;
    constructor(parent: Node, switchCase: SwitchCaseContext | SwitchDefaultContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class SwitchStatement extends Node {
    kind: Kind;
    discriminant: Expression;
    cases: SwitchCase[];
    constructor(parent: Node, switchStatement: SwitchStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class SwitchtypeCase extends Node {
    kind: Kind;
    tests: ClassType[];
    consequent: Statement;
    constructor(parent: Node, switchtypeCase: SwitchtypeCaseContext | SwitchtypeDefaultContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class SwitchtypeStatement extends Node {
    kind: Kind;
    discriminant: Expression;
    alias?: Identifier;
    cases: SwitchtypeCase[];
    constructor(parent: Node, switchtypeStatement: SwitchtypeStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ConditionalBranch extends Node {
    kind: Kind;
    test?: Expression;
    consequent: Statement;
    constructor(parent: Node, branch: IfBranchContext | ElseIfBranchContext | ElseBranchContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ConditionalStatement extends Node {
    kind: Kind;
    branches: ConditionalBranch[];
    constructor(parent: Node, conditionalStatement: ConditionalStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class LogStatement extends Node {
    kind: Kind;
    expression: Expression;
    constructor(parent: Node, logStatement: LogStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class SleepStatement extends Node {
    kind: Kind;
    expression: Expression;
    constructor(parent: Node, sleepStatement: SleepStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class TuningstartStatement extends Node {
    kind: Kind;
    constructor(parent: Node, tuningstartStatement: TuningstartStatementContext);
}
declare class TuningendStatement extends Node {
    kind: Kind;
    constructor(parent: Node, tuningendStatement: TuningendStatementContext);
}
declare class TuningmarkStatement extends Node {
    kind: Kind;
    label: TextLiteral;
    constructor(parent: Node, tuningmarkStatement: TuningmarkStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class WaitStatement extends Node {
    kind: Kind;
    expression: Expression;
    constructor(parent: Node, waitStatement: WaitStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class YieldStatement extends Node {
    kind: Kind;
    constructor(parent: Node, yieldStatement: YieldStatementContext);
}
type Expression = (VectorExpression | ArrayExpression | StructExpression | Literal | AsExpression | IsExpression | DotAccessExpression | IndexAccessExpression | UnaryExpression | BinaryExpression | LogicalExpression | TemplateTextLiteral | DumptypeExpression | DumpExpression | CastExpression | Identifier | ThisExpression | NowExpression | InvalidExpression);
declare function isExpression(node: Node): node is Expression;
declare class InvalidExpression extends Node {
    kind: Kind;
    error: Error | null;
    constructor(parent: Node | undefined, start: Token | null, stop?: Token | null, error?: Error | null);
}
declare class VectorExpression extends Node {
    kind: Kind;
    values: Expression[];
    constructor(parent: Node, vector: VectorContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ArrayExpression extends Node {
    kind: Kind;
    values: {
        key?: Expression;
        value: Expression;
    }[];
    isAssociative: boolean;
    constructor(parent: Node, array: ArrayContext | ArrayExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructMemberExpression extends Node {
    kind: Kind;
    name: Identifier;
    value: Expression;
    constructor(parent: Node, structureMemberInitialization: StructureMemberInitializationContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class StructExpression extends Node {
    kind: Kind;
    name: Identifier;
    members: StructMemberExpression[];
    constructor(parent: Node, structure: StructureContext | StructureExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class FunctionCallExpression extends Node {
    kind: Kind;
    name: Identifier;
    arguments: (Expression | InitializerType)[];
    constructor(parent: Node, functionCall: FunctionCallExpressionContext | FunctionCallContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class AsExpression extends Node {
    kind: Kind;
    expression: Expression;
    class: ClassType;
    constructor(parent: Node, asExpression: AsExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class IsExpression extends Node {
    kind: Kind;
    expression: Expression;
    class: ClassType;
    constructor(parent: Node, isExpression: IsExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class DotAccessExpression extends Node {
    kind: Kind;
    object: Expression;
    functionCall?: FunctionCallExpression;
    member?: Identifier;
    constructor(parent: Node, dotAccessExpression: DotAccessExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class IndexAccessExpression extends Node {
    kind: Kind;
    array: Expression;
    index: Expression;
    constructor(parent: Node, indexAccessExpression: IndexAccessExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare enum UnaryOperator {
    '-' = "-",
    '!' = "!"
}
declare class UnaryExpression extends Node {
    kind: Kind;
    operator: UnaryOperator;
    argument: Expression;
    constructor(parent: Node, unaryExpression: UnaryMinusExpressionContext | NotExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare enum BinaryOperator {
    '*' = "*",
    '/' = "/",
    '%' = "%",
    '+' = "+",
    '-' = "-",
    '^' = "^",
    '<' = "<",
    '>' = ">",
    '<=' = "<=",
    '>=' = ">=",
    '!=' = "!=",
    '==' = "=="
}
declare class BinaryExpression extends Node {
    kind: Kind;
    operator: BinaryOperator;
    left: Expression;
    right: Expression;
    constructor(parent: Node, binaryExpression: MultiplicativeExpressionContext | AdditiveExpressionContext | ConcatenationExpressionContext | RelationalExpressionContext | EqualityExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare enum LogicalOperator {
    '||' = "||",
    '&&' = "&&"
}
declare class LogicalExpression extends Node {
    kind: Kind;
    operator: LogicalOperator;
    left: Expression;
    right: Expression;
    constructor(parent: Node, logicalExpression: OrExpressionContext | AndExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class TemplateTextElement extends Node {
    kind: Kind;
    value: string;
    constructor(parent: Node, text: Token);
}
declare class TemplateTextLiteral extends Node {
    kind: Kind;
    expressions: Expression[];
    texts: TemplateTextElement[];
    constructor(parent: Node, textInterpolationExpression: TextInterpolationExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class DumptypeExpression extends Node {
    kind: Kind;
    type: Identifier;
    constructor(parent: Node, dumptypeExpression: DumptypeExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class DumpExpression extends Node {
    kind: Kind;
    expression: Expression;
    constructor(parent: Node, dumpExpression: DumpExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class CastExpression extends Node {
    kind: Kind;
    class: ClassType;
    expression: Expression;
    constructor(parent: Node, castExpression: CastExpressionContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare class ThisExpression extends Node {
    kind: Kind;
    constructor(parent: Node, thisExpression: ThisExpressionContext);
}
declare class NowExpression extends Node {
    kind: Kind;
    constructor(parent: Node, nowExpression: NowExpressionContext);
}
declare class Main extends Node {
    kind: Kind;
    body: BlockStatement;
    constructor(parent: Node, mainStatetement: MainStatementContext);
    visit(enterCb: VisitCallback, exitCb: VisitCallback): void;
}
declare function build(tree: ProgramContext): AST;
export { Kind, SourceLocationRange, Node, Program, TypeName, SimpleType, ClassType, EnumType, CustomType, InvalidType, ArrayType, InvalidLiteral, TextLiteral, IntegerLiteral, RealLiteral, BooleanLiteral, NullLiteral, NullIdLiteral, EnumLiteral, Identifier, InvalidIdentifier, RequireContextDirective, InvalidDirective, ExtendsDirective, IncludeDirective, InvalidSettingValue, SettingDirective, CommandDirective, StructMemberDeclaration, StructDeclaration, StructAliasing, StructDirective, InvalidConstValue, ConstDeclaration, ConstAliasing, ConstDirective, Storage, InitializerSign, InvalidDeclaration, VariableDeclaration, FunctionParameterDeclaration, FunctionDeclaration, LabelDeclaration, BlockStatement, InvalidStatement, ExpressionStatement, InvalidExpression, VectorExpression, ArrayExpression, StructMemberExpression, StructExpression, FunctionCallExpression, AsExpression, IsExpression, DotAccessExpression, IndexAccessExpression, UnaryExpression, UnaryOperator, BinaryExpression, BinaryOperator, LogicalExpression, LogicalOperator, TemplateTextLiteral, DumptypeExpression, DumpExpression, CastExpression, ThisExpression, NowExpression, AssignmentStatement, AssignmentOperator, ReturnStatement, LabelStatement, AssertStatement, ForeachStatement, ForStatement, WhileStatement, MeanwhileStatement, BreakStatement, ContinueStatement, SwitchStatement, SwitchCase, SwitchtypeStatement, SwitchtypeCase, ConditionalStatement, ConditionalBranch, LogStatement, SleepStatement, TuningstartStatement, TuningendStatement, TuningmarkStatement, WaitStatement, YieldStatement, Main, isBaseType, isInitializerType, isType, isLiteral, isDirective, isDeclaration, isStatement, isExpression, build };
export type { AST, BaseType, InitializerType, KeyType, Type, Literal, Directive, Declaration, Statement, Expression };