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 ARROW = 24;
    static readonly ColonEquals = 25;
    static readonly BooleanLiteral = 26;
    static readonly IntegerLiteral = 27;
    static readonly DecimalLiteral = 28;
    static readonly Break = 29;
    static readonly And = 30;
    static readonly For = 31;
    static readonly Continue = 32;
    static readonly If = 33;
    static readonly Or = 34;
    static readonly Not = 35;
    static readonly Else = 36;
    static readonly To = 37;
    static readonly By = 38;
    static readonly ColorLiteral = 39;
    static readonly StringLiteral = 40;
    static readonly Identifier = 41;
    static readonly HIDDEN_ = 42;
    static readonly COMMENT_ = 43;
    static readonly NEWLINE = 44;
    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_variableDeclarationList = 9;
    static readonly RULE_blockSequence = 10;
    static readonly RULE_expressionSequence = 11;
    static readonly RULE_expressionBlockSequence = 12;
    static readonly RULE_varBlockStmt = 13;
    static readonly RULE_varArrayDeclaration = 14;
    static readonly RULE_blockExpression = 15;
    static readonly RULE_singleExpression = 16;
    static readonly RULE_brackethesized = 17;
    static readonly RULE_arguments = 18;
    static readonly RULE_argument = 19;
    static readonly RULE_ifStatement = 20;
    static readonly RULE_forStatement = 21;
    static readonly RULE_literal = 22;
    static readonly RULE_methodStmt = 23;
    static readonly RULE_methodElement = 24;
    static readonly RULE_methodName = 25;
    static readonly RULE_arrowFunction = 26;
    static readonly RULE_arrowFunctionParameters = 27;
    static readonly RULE_formalParameterList = 28;
    static readonly RULE_assignmentOperator = 29;
    static readonly RULE_identifier = 30;
    static readonly RULE_name = 31;
    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;
    variableDeclarationList(): VariableDeclarationListContext;
    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;
    literal(): LiteralContext;
    methodStmt(): MethodStmtContext;
    methodElement(): MethodElementContext;
    methodName(): MethodNameContext;
    arrowFunction(): ArrowFunctionContext;
    arrowFunctionParameters(): ArrowFunctionParametersContext;
    formalParameterList(): FormalParameterListContext;
    assignmentOperator(): AssignmentOperatorContext;
    identifier(): IdentifierContext;
    name(): NameContext;
    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;
    arrowFunction(): ArrowFunctionContext;
    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;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    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);
    identifier(): IdentifierContext;
    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 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;
    identifier(): IdentifierContext;
    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;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class BlockExpressionContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    ifStatement(): IfStatementContext;
    forStatement(): ForStatementContext;
    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;
    By(): TerminalNode;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    BooleanLiteral(): TerminalNode;
    ColorLiteral(): 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;
    Point_list(): TerminalNode[];
    Point(i: number): 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;
    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);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    Comma_list(): TerminalNode[];
    Comma(i: number): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class AssignmentOperatorContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    ColonEquals(): TerminalNode;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    constructor(parser?: tccScriptParser, parent?: ParserRuleContext, invokingState?: number);
    Identifier(): TerminalNode;
    BooleanLiteral(): 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;
    get ruleIndex(): number;
    accept<Result>(visitor: tccScriptParserVisitor<Result>): Result;
}