import { Parser, ParserRuleContext } from 'antlr4';
import tccScriptParserVisitor from "./tccScriptParserVisitor.js";
export default class tccScriptParser extends Parser {
    static readonly INDENT = 1;
    static readonly DEDENT = 2;
    static readonly Point = 3;
    static readonly OpenBracket = 4;
    static readonly CloseBracket = 5;
    static readonly OpenParen = 6;
    static readonly CloseParen = 7;
    static readonly Comma = 8;
    static readonly Assign = 9;
    static readonly QuestionMark = 10;
    static readonly Colon = 11;
    static readonly Plus = 12;
    static readonly Minus = 13;
    static readonly Multiply = 14;
    static readonly Divide = 15;
    static readonly Modulus = 16;
    static readonly Hashtag = 17;
    static readonly LessThan = 18;
    static readonly MoreThan = 19;
    static readonly LessThanEquals = 20;
    static readonly GreaterThanEquals = 21;
    static readonly Equals_ = 22;
    static readonly NotEquals = 23;
    static readonly MultiplyAssign = 24;
    static readonly DivideAssign = 25;
    static readonly ModulusAssign = 26;
    static readonly PlusAssign = 27;
    static readonly MinusAssign = 28;
    static readonly ARROW = 29;
    static readonly ColonEquals = 30;
    static readonly BooleanLiteral = 31;
    static readonly IntegerLiteral = 32;
    static readonly DecimalLiteral = 33;
    static readonly Break = 34;
    static readonly And = 35;
    static readonly Export = 36;
    static readonly For = 37;
    static readonly Var = 38;
    static readonly Continue = 39;
    static readonly Varip = 40;
    static readonly Switch = 41;
    static readonly While = 42;
    static readonly If = 43;
    static readonly In = 44;
    static readonly Or = 45;
    static readonly Not = 46;
    static readonly Method = 47;
    static readonly Else = 48;
    static readonly To = 49;
    static readonly By = 50;
    static readonly Type = 51;
    static readonly Import = 52;
    static readonly As = 53;
    static readonly Enum = 54;
    static readonly Map = 55;
    static readonly ColorLiteral = 56;
    static readonly StringLiteral = 57;
    static readonly MultiDoubleStringLiteral = 58;
    static readonly MultiSingleStringLiteral = 59;
    static readonly Identifier = 60;
    static readonly HIDDEN_ = 61;
    static readonly COMMENT_ = 62;
    static readonly NEWLINE = 63;
    static readonly EOF: any;
    static readonly RULE_program = 0;
    static readonly RULE_globalStmt = 1;
    static readonly RULE_blockStmt = 2;
    static readonly RULE_stmt = 3;
    static readonly RULE_simpleStmt = 4;
    static readonly RULE_flowStmt = 5;
    static readonly RULE_block = 6;
    static readonly RULE_blockLine = 7;
    static readonly RULE_variableDeclarationStmt = 8;
    static readonly RULE_exportDeclareAssign = 9;
    static readonly RULE_variableDeclarationList = 10;
    static readonly RULE_againAssignName = 11;
    static readonly RULE_varModifier = 12;
    static readonly RULE_blockSequence = 13;
    static readonly RULE_expressionSequence = 14;
    static readonly RULE_expressionBlockSequence = 15;
    static readonly RULE_varBlockStmt = 16;
    static readonly RULE_varArrayDeclaration = 17;
    static readonly RULE_blockExpression = 18;
    static readonly RULE_singleExpression = 19;
    static readonly RULE_brackethesized = 20;
    static readonly RULE_arguments = 21;
    static readonly RULE_argument = 22;
    static readonly RULE_ifStatement = 23;
    static readonly RULE_forStatement = 24;
    static readonly RULE_switchStatement = 25;
    static readonly RULE_caseClause = 26;
    static readonly RULE_defaultCaluse = 27;
    static readonly RULE_whileStatement = 28;
    static readonly RULE_importStmt = 29;
    static readonly RULE_importElement = 30;
    static readonly RULE_literal = 31;
    static readonly RULE_methodStmt = 32;
    static readonly RULE_methodElement = 33;
    static readonly RULE_methodName = 34;
    static readonly RULE_arrowFunction = 35;
    static readonly RULE_arrowFunctionParameters = 36;
    static readonly RULE_formalParameterList = 37;
    static readonly RULE_formalParameterArg = 38;
    static readonly RULE_arrowMethod = 39;
    static readonly RULE_arrowMethodParameters = 40;
    static readonly RULE_typeStatement = 41;
    static readonly RULE_typeElement = 42;
    static readonly RULE_assignmentOperator = 43;
    static readonly RULE_typeMap = 44;
    static readonly RULE_typeSeries = 45;
    static readonly RULE_typeArray = 46;
    static readonly RULE_typeGather = 47;
    static readonly RULE_identifier = 48;
    static readonly RULE_typeName = 49;
    static readonly RULE_name = 50;
    static readonly RULE_enumStatement = 51;
    static readonly RULE_enumElement = 52;
    static readonly literalNames: (string | null)[];
    static readonly symbolicNames: (string | null)[];
    static readonly ruleNames: string[];
    get grammarFileName(): string;
    get literalNames(): (string | null)[];
    get symbolicNames(): (string | null)[];
    get ruleNames(): string[];
    get serializedATN(): number[];
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    program(): ProgramContext;
    globalStmt(): GlobalStmtContext;
    blockStmt(): BlockStmtContext;
    stmt(): StmtContext;
    simpleStmt(): SimpleStmtContext;
    flowStmt(): FlowStmtContext;
    block(): BlockContext;
    blockLine(): BlockLineContext;
    variableDeclarationStmt(): VariableDeclarationStmtContext;
    exportDeclareAssign(): ExportDeclareAssignContext;
    variableDeclarationList(): VariableDeclarationListContext;
    againAssignName(): AgainAssignNameContext;
    varModifier(): VarModifierContext;
    blockSequence(): BlockSequenceContext;
    expressionSequence(): ExpressionSequenceContext;
    expressionBlockSequence(): ExpressionBlockSequenceContext;
    varBlockStmt(): VarBlockStmtContext;
    varArrayDeclaration(): VarArrayDeclarationContext;
    blockExpression(): BlockExpressionContext;
    singleExpression(): SingleExpressionContext;
    singleExpression(_p: number): SingleExpressionContext;
    brackethesized(): BrackethesizedContext;
    arguments(): ArgumentsContext;
    argument(): ArgumentContext;
    ifStatement(): IfStatementContext;
    forStatement(): ForStatementContext;
    switchStatement(): SwitchStatementContext;
    caseClause(): CaseClauseContext;
    defaultCaluse(): DefaultCaluseContext;
    whileStatement(): WhileStatementContext;
    importStmt(): ImportStmtContext;
    importElement(): ImportElementContext;
    literal(): LiteralContext;
    methodStmt(): MethodStmtContext;
    methodElement(): MethodElementContext;
    methodName(): MethodNameContext;
    arrowFunction(): ArrowFunctionContext;
    arrowFunctionParameters(): ArrowFunctionParametersContext;
    formalParameterList(): FormalParameterListContext;
    formalParameterArg(): FormalParameterArgContext;
    arrowMethod(): ArrowMethodContext;
    arrowMethodParameters(): ArrowMethodParametersContext;
    typeStatement(): TypeStatementContext;
    typeElement(): TypeElementContext;
    assignmentOperator(): AssignmentOperatorContext;
    typeMap(): TypeMapContext;
    typeSeries(): TypeSeriesContext;
    typeArray(): TypeArrayContext;
    typeGather(): TypeGatherContext;
    identifier(): IdentifierContext;
    typeName(): TypeNameContext;
    name(): NameContext;
    enumStatement(): EnumStatementContext;
    enumElement(): EnumElementContext;
    sempred(localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private singleExpression_sempred;
    static readonly _serializedATN: number[];
    private static __ATN;
    static get _ATN(): ATN;
    static DecisionsToDFA: any;
}
export declare class ProgramContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    EOF(): TerminalNode;
    NEWLINE_list(): TerminalNode[];
    NEWLINE(i: number): TerminalNode;
    globalStmt_list(): GlobalStmtContext[];
    globalStmt(i: number): GlobalStmtContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class GlobalStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    variableDeclarationStmt(): VariableDeclarationStmtContext;
    NEWLINE(): TerminalNode;
    Comma(): TerminalNode;
    blockStmt(): BlockStmtContext;
    importStmt(): ImportStmtContext;
    arrowFunction(): ArrowFunctionContext;
    arrowMethod(): ArrowMethodContext;
    typeStatement(): TypeStatementContext;
    enumStatement(): EnumStatementContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    varBlockStmt(): VarBlockStmtContext;
    blockExpression(): BlockExpressionContext;
    variableDeclarationStmt_list(): VariableDeclarationStmtContext[];
    variableDeclarationStmt(i: number): VariableDeclarationStmtContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class StmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    simpleStmt(): SimpleStmtContext;
    NEWLINE(): TerminalNode;
    Comma(): TerminalNode;
    expressionBlockSequence(): ExpressionBlockSequenceContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class SimpleStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    expressionSequence(): ExpressionSequenceContext;
    blockSequence(): BlockSequenceContext;
    brackethesized(): BrackethesizedContext;
    flowStmt(): FlowStmtContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class FlowStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Break(): TerminalNode;
    Continue(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    simpleStmt(): SimpleStmtContext;
    NEWLINE(): TerminalNode;
    Comma(): TerminalNode;
    blockLine(): BlockLineContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockLineContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    NEWLINE(): TerminalNode;
    INDENT(): TerminalNode;
    DEDENT(): TerminalNode;
    stmt_list(): StmtContext[];
    stmt(i: number): StmtContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VariableDeclarationStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    methodStmt_list(): MethodStmtContext[];
    methodStmt(i: number): MethodStmtContext;
    variableDeclarationList_list(): VariableDeclarationListContext[];
    variableDeclarationList(i: number): VariableDeclarationListContext;
    exportDeclareAssign_list(): ExportDeclareAssignContext[];
    exportDeclareAssign(i: number): ExportDeclareAssignContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ExportDeclareAssignContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Export(): TerminalNode;
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Assign(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VariableDeclarationListContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: VariableDeclarationListContext): void;
}
export declare class AgainAssignContext extends VariableDeclarationListContext {
    constructor(parser: tccScriptParser, ctx: VariableDeclarationListContext);
    againAssignName(): AgainAssignNameContext;
    assignmentOperator(): AssignmentOperatorContext;
    singleExpression(): SingleExpressionContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class DeclareAssignContext extends VariableDeclarationListContext {
    constructor(parser: tccScriptParser, ctx: VariableDeclarationListContext);
    varArrayDeclaration(): VarArrayDeclarationContext;
    Assign(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class AgainAssignNameContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Point_list(): TerminalNode[];
    Point(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VarModifierContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Var(): TerminalNode;
    Varip(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockSequenceContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    variableDeclarationList_list(): VariableDeclarationListContext[];
    variableDeclarationList(i: number): VariableDeclarationListContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ExpressionSequenceContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ExpressionBlockSequenceContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    varBlockStmt(): VarBlockStmtContext;
    blockExpression(): BlockExpressionContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    variableDeclarationList_list(): VariableDeclarationListContext[];
    variableDeclarationList(i: number): VariableDeclarationListContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VarBlockStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    blockExpression(): BlockExpressionContext;
    varArrayDeclaration(): VarArrayDeclarationContext;
    Assign(): TerminalNode;
    againAssignName(): AgainAssignNameContext;
    assignmentOperator(): AssignmentOperatorContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VarArrayDeclarationContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: VarArrayDeclarationContext): void;
}
export declare class VarMultipleContext extends VarArrayDeclarationContext {
    constructor(parser: tccScriptParser, ctx: VarArrayDeclarationContext);
    OpenBracket(): TerminalNode;
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    CloseBracket(): TerminalNode;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class VarSingleContext extends VarArrayDeclarationContext {
    constructor(parser: tccScriptParser, ctx: VarArrayDeclarationContext);
    identifier(): IdentifierContext;
    varModifier(): VarModifierContext;
    typeGather(): TypeGatherContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockExpressionContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    ifStatement(): IfStatementContext;
    forStatement(): ForStatementContext;
    whileStatement(): WhileStatementContext;
    switchStatement(): SwitchStatementContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class SingleExpressionContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: SingleExpressionContext): void;
}
export declare class ParenthesizedExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    OpenParen(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    CloseParen(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class AdditiveExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Plus(): TerminalNode;
    Minus(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class RelationalExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    LessThan(): TerminalNode;
    MoreThan(): TerminalNode;
    LessThanEquals(): TerminalNode;
    GreaterThanEquals(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TernaryExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    QuestionMark(): TerminalNode;
    Colon(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class LogicalAndExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    And(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class NameExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    name(): NameContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class LiteralExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    literal(): LiteralContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class LogicalOrExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Or(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class UnaryExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression(): SingleExpressionContext;
    Minus(): TerminalNode;
    Plus(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class NotExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    Not(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MemberIndexExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    OpenBracket(): TerminalNode;
    CloseBracket(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MethodExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    methodStmt(): MethodStmtContext;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class EqualityExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Equals_(): TerminalNode;
    NotEquals(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MultiplicativeExpressionContext extends SingleExpressionContext {
    constructor(parser: tccScriptParser, ctx: SingleExpressionContext);
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    Multiply(): TerminalNode;
    Divide(): TerminalNode;
    Modulus(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BrackethesizedContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    OpenBracket(): TerminalNode;
    expressionSequence(): ExpressionSequenceContext;
    CloseBracket(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArgumentsContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    OpenParen(): TerminalNode;
    CloseParen(): TerminalNode;
    argument_list(): ArgumentContext[];
    argument(i: number): ArgumentContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArgumentContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    singleExpression(): SingleExpressionContext;
    brackethesized(): BrackethesizedContext;
    identifier(): IdentifierContext;
    Assign(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class IfStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    If_list(): TerminalNode[];
    If(i: number): TerminalNode;
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    blockLine_list(): BlockLineContext[];
    blockLine(i: number): BlockLineContext;
    Else_list(): TerminalNode[];
    Else(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ForStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    copyFrom(ctx: ForStatementContext): void;
}
export declare class ForToStatementContext extends ForStatementContext {
    constructor(parser: tccScriptParser, ctx: ForStatementContext);
    For(): TerminalNode;
    identifier(): IdentifierContext;
    Assign(): TerminalNode;
    singleExpression_list(): SingleExpressionContext[];
    singleExpression(i: number): SingleExpressionContext;
    To(): TerminalNode;
    blockLine(): BlockLineContext;
    varModifier(): VarModifierContext;
    typeGather(): TypeGatherContext;
    By(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ForInStatementContext extends ForStatementContext {
    constructor(parser: tccScriptParser, ctx: ForStatementContext);
    For(): TerminalNode;
    In(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    blockLine(): BlockLineContext;
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    OpenBracket(): TerminalNode;
    Comma(): TerminalNode;
    CloseBracket(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class SwitchStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Switch(): TerminalNode;
    NEWLINE(): TerminalNode;
    INDENT(): TerminalNode;
    DEDENT(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    defaultCaluse(): DefaultCaluseContext;
    caseClause_list(): CaseClauseContext[];
    caseClause(i: number): CaseClauseContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class CaseClauseContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    singleExpression(): SingleExpressionContext;
    ARROW(): TerminalNode;
    block(): BlockContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class DefaultCaluseContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    ARROW(): TerminalNode;
    block(): BlockContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class WhileStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    While(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    blockLine(): BlockLineContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ImportStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    importElement_list(): ImportElementContext[];
    importElement(i: number): ImportElementContext;
    NEWLINE(): TerminalNode;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ImportElementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Import(): TerminalNode;
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Divide_list(): TerminalNode[];
    Divide(i: number): TerminalNode;
    IntegerLiteral(): TerminalNode;
    As(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    BooleanLiteral(): TerminalNode;
    ColorLiteral(): TerminalNode;
    MultiDoubleStringLiteral(): TerminalNode;
    MultiSingleStringLiteral(): TerminalNode;
    StringLiteral(): TerminalNode;
    IntegerLiteral(): TerminalNode;
    DecimalLiteral(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MethodStmtContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    methodElement_list(): MethodElementContext[];
    methodElement(i: number): MethodElementContext;
    Point_list(): TerminalNode[];
    Point(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MethodElementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    methodName(): MethodNameContext;
    arguments(): ArgumentsContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class MethodNameContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    OpenParen(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    CloseParen(): TerminalNode;
    Point_list(): TerminalNode[];
    Point(i: number): TerminalNode;
    StringLiteral(): TerminalNode;
    LessThan(): TerminalNode;
    typeName_list(): TypeNameContext[];
    typeName(i: number): TypeNameContext;
    MoreThan(): TerminalNode;
    Comma(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArrowFunctionContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    arrowFunctionParameters(): ArrowFunctionParametersContext;
    ARROW(): TerminalNode;
    block(): BlockContext;
    Export(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArrowFunctionParametersContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    OpenParen(): TerminalNode;
    CloseParen(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class FormalParameterListContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    formalParameterArg_list(): FormalParameterArgContext[];
    formalParameterArg(i: number): FormalParameterArgContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class FormalParameterArgContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    typeGather(): TypeGatherContext;
    Assign(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArrowMethodContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Method(): TerminalNode;
    identifier(): IdentifierContext;
    arrowMethodParameters(): ArrowMethodParametersContext;
    ARROW(): TerminalNode;
    block(): BlockContext;
    Export(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class ArrowMethodParametersContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    OpenParen(): TerminalNode;
    typeGather(): TypeGatherContext;
    identifier(): IdentifierContext;
    CloseParen(): TerminalNode;
    Assign(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    Comma(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Type(): TerminalNode;
    identifier(): IdentifierContext;
    NEWLINE(): TerminalNode;
    INDENT(): TerminalNode;
    DEDENT(): TerminalNode;
    Export(): TerminalNode;
    typeElement_list(): TypeElementContext[];
    typeElement(i: number): TypeElementContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeElementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    NEWLINE(): TerminalNode;
    Varip(): TerminalNode;
    typeGather(): TypeGatherContext;
    Assign(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class AssignmentOperatorContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    ColonEquals(): TerminalNode;
    MultiplyAssign(): TerminalNode;
    DivideAssign(): TerminalNode;
    ModulusAssign(): TerminalNode;
    PlusAssign(): TerminalNode;
    MinusAssign(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeMapContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Map(): TerminalNode;
    LessThan(): TerminalNode;
    Comma(): TerminalNode;
    typeName_list(): TypeNameContext[];
    typeName(i: number): TypeNameContext;
    MoreThan(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeSeriesContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    typeName_list(): TypeNameContext[];
    typeName(i: number): TypeNameContext;
    typeArray(): TypeArrayContext;
    typeMap(): TypeMapContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeArrayContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    typeName_list(): TypeNameContext[];
    typeName(i: number): TypeNameContext;
    LessThan(): TerminalNode;
    MoreThan(): TerminalNode;
    OpenBracket(): TerminalNode;
    CloseBracket(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeGatherContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    typeName(): TypeNameContext;
    typeArray(): TypeArrayContext;
    typeMap(): TypeMapContext;
    typeSeries(): TypeSeriesContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Identifier(): TerminalNode;
    Map(): TerminalNode;
    Type(): TerminalNode;
    Enum(): TerminalNode;
    Method(): TerminalNode;
    BooleanLiteral(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class TypeNameContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Point(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class NameContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Point_list(): TerminalNode[];
    Point(i: number): TerminalNode;
    methodElement_list(): MethodElementContext[];
    methodElement(i: number): MethodElementContext;
    OpenParen(): TerminalNode;
    singleExpression(): SingleExpressionContext;
    CloseParen(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class EnumStatementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Enum(): TerminalNode;
    identifier(): IdentifierContext;
    NEWLINE(): TerminalNode;
    INDENT(): TerminalNode;
    DEDENT(): TerminalNode;
    Export(): TerminalNode;
    enumElement_list(): EnumElementContext[];
    enumElement(i: number): EnumElementContext;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class EnumElementContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    NEWLINE(): TerminalNode;
    Assign(): TerminalNode;
    StringLiteral(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}