stepcode/dist/index.d.ts

A parser for StepCode

import { ATN } from 'antlr4';
import { CharStream } from 'antlr4';
import { DFA } from 'antlr4';
import { DimensionReturnType } from './visitor-return-types';
import { ErrorListener } from 'antlr4';
import { FailedPredicateException } from 'antlr4';
import { IdentifierReturnType } from './visitor-return-types';
import { Lexer } from 'antlr4';
import { Parser } from 'antlr4';
import { ParserRuleContext } from 'antlr4';
import { ParseTree } from 'antlr4';
import { ParseTreeListener } from 'antlr4';
import { ParseTreeVisitor } from 'antlr4';
import { Recognizer } from 'antlr4';
import { ReturnTypes } from './visitor-return-types';
import { RuleContext } from 'antlr4';
import { RuleNode } from 'antlr4';
import { TerminalNode } from 'antlr4';
import { Token } from 'antlr4';
import { TokenStream } from 'antlr4';
import { ValidDataType } from './interpreter-types';

declare class AccessorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    index(): IndexContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ActualParameterContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    parameterwidth_list(): ParameterwidthContext[];
    parameterwidth(i: number): ParameterwidthContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class AdditiveoperatorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ArrayTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    ARRAY(): TerminalNode;
    LBRACK(): TerminalNode;
    typeList(): TypeListContext;
    RBRACK(): TerminalNode;
    OF(): TerminalNode;
    componentType(): ComponentTypeContext;
    LBRACK2(): TerminalNode;
    RBRACK2(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class AssignationFunctionDeclarationContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    ASSIGN(): TerminalNode;
    block(): BlockContext;
    ENDFUNCTION(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class AssignmentStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    variable(): VariableContext;
    ASSIGN(): TerminalNode;
    expression(): ExpressionContext;
    SEMI(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BaseTermContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    signedFactor(): SignedFactorContext;
    baseTerm_list(): BaseTermContext[];
    baseTerm(i: number): BaseTermContext;
    exponentiationOperator(): ExponentiationOperatorContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BaseTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    simpleType(): SimpleTypeContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BlockContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    labelDeclarationPart_list(): LabelDeclarationPartContext[];
    labelDeclarationPart(i: number): LabelDeclarationPartContext;
    constantDefinitionPart_list(): ConstantDefinitionPartContext[];
    constantDefinitionPart(i: number): ConstantDefinitionPartContext;
    typeDefinitionPart_list(): TypeDefinitionPartContext[];
    typeDefinitionPart(i: number): TypeDefinitionPartContext;
    variableDeclarationPart_list(): VariableDeclarationPartContext[];
    variableDeclarationPart(i: number): VariableDeclarationPartContext;
    dimensionStatement_list(): DimensionStatementContext[];
    dimensionStatement(i: number): DimensionStatementContext;
    procedureAndFunctionDeclarationPart_list(): ProcedureAndFunctionDeclarationPartContext[];
    procedureAndFunctionDeclarationPart(i: number): ProcedureAndFunctionDeclarationPartContext;
    usesUnitsPart_list(): UsesUnitsPartContext[];
    usesUnitsPart(i: number): UsesUnitsPartContext;
    IMPLEMENTATION_list(): TerminalNode[];
    IMPLEMENTATION(i: number): TerminalNode;
    statements_list(): StatementsContext[];
    statements(i: number): StatementsContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class Bool_Context extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    TRUE(): TerminalNode;
    FALSE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BooleanMultiplicativeExpressionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    booleanRelationalExpression(): BooleanRelationalExpressionContext;
    booleanMultiplicativeExpression_list(): BooleanMultiplicativeExpressionContext[];
    booleanMultiplicativeExpression(i: number): BooleanMultiplicativeExpressionContext;
    AND(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BooleanRelationalExpressionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    simpleExpression(): SimpleExpressionContext;
    booleanRelationalExpression_list(): BooleanRelationalExpressionContext[];
    booleanRelationalExpression(i: number): BooleanRelationalExpressionContext;
    relationaloperator(): RelationaloperatorContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class BreakStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    BREAK(): TerminalNode;
    SEMI(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class CaseListElementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    constList(): ConstListContext;
    compoundStatement(): CompoundStatementContext;
    COLON(): TerminalNode;
    AS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class CaseOtherWiseContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    compoundStatement(): CompoundStatementContext;
    ELSE(): TerminalNode;
    OTHERWISE(): TerminalNode;
    COLON(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class CaseStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    CASE(): TerminalNode;
    expression(): ExpressionContext;
    ENDCASE(): TerminalNode;
    OF(): TerminalNode;
    HACER(): TerminalNode;
    caseListElement_list(): CaseListElementContext[];
    caseListElement(i: number): CaseListElementContext;
    caseOtherWise(): CaseOtherWiseContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare class CollectorErrorListener extends ErrorListener<Token> {
    private errors;
    constructor();
    syntaxError(_recognizer: Recognizer<Token>, offendingSymbol: Token, line: number, column: number, msg: string, _e: any): void;
    getErrors(): StepCodeError[];
}

declare class ComponentTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    type_(): Type_Context;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class CompoundStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    statements_list(): StatementsContext[];
    statements(i: number): StatementsContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConditionalStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    ifStatement(): IfStatementContext;
    caseStatement(): CaseStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConstantChrContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    CHR(): TerminalNode;
    LPAREN(): TerminalNode;
    unsignedInteger(): UnsignedIntegerContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConstantContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    unsignedNumber(): UnsignedNumberContext;
    sign(): SignContext;
    identifier(): IdentifierContext;
    string_(): StringContext;
    constantChr(): ConstantChrContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConstantDefinitionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    EQUAL(): TerminalNode;
    constant(): ConstantContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConstantDefinitionPartContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    CONST(): TerminalNode;
    constantDefinition_list(): ConstantDefinitionContext[];
    constantDefinition(i: number): ConstantDefinitionContext;
    SEMI_list(): TerminalNode[];
    SEMI(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ConstListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    constant_list(): ConstantContext[];
    constant(i: number): ConstantContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ContinueStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    CONTINUE(): TerminalNode;
    SEMI(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare function createLexer(code: string): StepCodeLexer;

export declare function createNDArray(shape: number[], type: ValidDataType): {
    array: any[];
    type: string;
};

export declare function createParser(code: string): StepCodeParser;

export declare function createParserFromLexer(lexer: StepCodeLexer): StepCodeParser;

export declare function createTokens(code: string): Token[];

declare class DimensionStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    DIMENSION(): TerminalNode;
    identifier(): IdentifierContext;
    dimensionType(): DimensionTypeContext;
    SEMI(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class DimensionTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACK(): TerminalNode;
    unsignedNumber_list(): UnsignedNumberContext[];
    unsignedNumber(i: number): UnsignedNumberContext;
    RBRACK(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class DirectivesContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    DIRECTIVE(): TerminalNode;
    IDENT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ElementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    DOTDOT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ElementListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    element_list(): ElementContext[];
    element(i: number): ElementContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ElifStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    ELIF(): TerminalNode;
    expression(): ExpressionContext;
    THEN(): TerminalNode;
    compoundStatement(): CompoundStatementContext;
    elifStatement(): ElifStatementContext;
    ENDIF(): TerminalNode;
    elseStatement(): ElseStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ElseStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    ELSE(): TerminalNode;
    compoundStatement(): CompoundStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class Empty_Context extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class EmptyStatement_Context extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare class EventBus {
    private listeners;
    constructor();
    on(event: string, callback: Function): void;
    emit(event: string, ...args: any[]): void;
}

declare class ExponentiationOperatorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    POWER(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ExpressionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    booleanMultiplicativeExpression(): BooleanMultiplicativeExpressionContext;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    OR(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FactorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    variable(): VariableContext;
    LPAREN(): TerminalNode;
    expression(): ExpressionContext;
    RPAREN(): TerminalNode;
    functionDesignator(): FunctionDesignatorContext;
    unsignedConstant(): UnsignedConstantContext;
    set_(): Set_Context;
    NOT(): TerminalNode;
    factor(): FactorContext;
    bool_(): Bool_Context;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FieldListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    fixedPart(): FixedPartContext;
    SEMI(): TerminalNode;
    variantPart(): VariantPartContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FileTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    FILE(): TerminalNode;
    OF(): TerminalNode;
    type_(): Type_Context;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FinalValueContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FixedPartContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    recordSection_list(): RecordSectionContext[];
    recordSection(i: number): RecordSectionContext;
    SEMI_list(): TerminalNode[];
    SEMI(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ForListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    initialValue(): InitialValueContext;
    finalValue(): FinalValueContext;
    TO(): TerminalNode;
    DOWNTO(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FormalParameterListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    formalParameterSection(): FormalParameterSectionContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FormalParameterSectionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    paramIdentifier_list(): ParamIdentifierContext[];
    paramIdentifier(i: number): ParamIdentifierContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ForStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    FOR(): TerminalNode;
    identifier(): IdentifierContext;
    ASSIGN(): TerminalNode;
    forList(): ForListContext;
    compoundStatement(): CompoundStatementContext;
    ENDFOR(): TerminalNode;
    DO(): TerminalNode;
    HACER(): TerminalNode;
    WITHSTEP(): TerminalNode;
    stepValue(): StepValueContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FunctionDeclarationContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    identifier(): IdentifierContext;
    COLON(): TerminalNode;
    resultType(): ResultTypeContext;
    block(): BlockContext;
    ENDFUNCTION(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FunctionDesignatorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    parameterList(): ParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class FunctionTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    FUNCTION(): TerminalNode;
    COLON(): TerminalNode;
    resultType(): ResultTypeContext;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare function getInterpreterType(type: string): ValidDataType;

declare class GotoStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    GOTO(): TerminalNode;
    label(): LabelContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class IdentifierContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    IDENT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class IdentifierListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifier_list(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class IfStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    IF(): TerminalNode;
    expression(): ExpressionContext;
    THEN(): TerminalNode;
    compoundStatement(): CompoundStatementContext;
    ENDIF(): TerminalNode;
    elifStatement(): ElifStatementContext;
    elseStatement(): ElseStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class IndexContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACK(): TerminalNode;
    expression_list(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    RBRACK(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class IndexTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    simpleType(): SimpleTypeContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class InitialValueContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare function interpret({ code, ...props }: InterpretProps): Promise<void>;

declare type InterpretBaseProps = {
    code: string;
    eventBus: EventBus;
};

export declare type InterpretProps = InterpretBaseProps | InterpretWithLexerProps | InterpretWithInterpreterProps | InterpretWithParserProps;

declare type InterpretWithInterpreterProps = {
    code: string;
    interpreter: StepCodeInterpreter;
};

declare type InterpretWithLexerProps = InterpretBaseProps & {
    lexer: StepCodeLexer;
    eventBus: EventBus;
};

declare type InterpretWithParserProps = InterpretBaseProps & {
    parser: StepCodeParser;
};

export declare function isCompatibleType(expected: ValidDataType, actual: ValidDataType): boolean;

export declare function isStructuredType(type: ValidDataType): boolean;

declare class LabelContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    unsignedInteger(): UnsignedIntegerContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class LabelDeclarationPartContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LABEL(): TerminalNode;
    label_list(): LabelContext[];
    label(i: number): LabelContext;
    SEMI(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class MainContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    programHeading(): ProgramHeadingContext;
    block(): BlockContext;
    ENDPROGRAM(): TerminalNode;
    INTERFACE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class MultiplicativeoperatorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    STAR(): TerminalNode;
    SLASH(): TerminalNode;
    DIV(): TerminalNode;
    MOD(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ParameterListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    actualParameter_list(): ActualParameterContext[];
    actualParameter(i: number): ActualParameterContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ParameterwidthContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    COLON(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ParamIdentifierContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    typeIdentifier(): TypeIdentifierContext;
    COLON(): TerminalNode;
    AS(): TerminalNode;
    BYVALUE(): TerminalNode;
    BYREFERENCE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare function parseTree(code: string): ProgramContext;

export declare function parseValue(type: ValidDataType, value: string): any;

declare class PointerTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    POINTER(): TerminalNode;
    typeIdentifier(): TypeIdentifierContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProcedureAndFunctionDeclarationPartContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    procedureOrFunctionDeclaration(): ProcedureOrFunctionDeclarationContext;
    SEMI(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProcedureDeclarationContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    PROCEDURE(): TerminalNode;
    identifier(): IdentifierContext;
    block(): BlockContext;
    ENDPROCEDURE(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProcedureOrFunctionDeclarationContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    procedureDeclaration(): ProcedureDeclarationContext;
    functionDeclaration(): FunctionDeclarationContext;
    assignationFunctionDeclaration(): AssignationFunctionDeclarationContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProcedureStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifier(): IdentifierContext;
    LPAREN(): TerminalNode;
    RPAREN(): TerminalNode;
    parameterList(): ParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProcedureTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    PROCEDURE(): TerminalNode;
    formalParameterList(): FormalParameterListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProgramContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    main(): MainContext;
    EOF(): TerminalNode;
    directives_list(): DirectivesContext[];
    directives(i: number): DirectivesContext;
    subprogram_list(): SubprogramContext[];
    subprogram(i: number): SubprogramContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ProgramHeadingContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    PROGRAM(): TerminalNode;
    identifier(): IdentifierContext;
    LPAREN(): TerminalNode;
    identifierList(): IdentifierListContext;
    RPAREN(): TerminalNode;
    UNIT(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare type Props = {
    startLine: number;
    startColumn: number;
    endLine: number;
    endColumn: number;
    message: string;
};

declare class ReadStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    READ(): TerminalNode;
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    SEMI(): TerminalNode;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RecordSectionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    identifierList(): IdentifierListContext;
    COLON(): TerminalNode;
    type_(): Type_Context;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RecordTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    RECORD(): TerminalNode;
    END(): TerminalNode;
    fieldList(): FieldListContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RecordVariableListContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    variable_list(): VariableContext[];
    variable(i: number): VariableContext;
    COMMA_list(): TerminalNode[];
    COMMA(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RelationaloperatorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    EQUAL(): TerminalNode;
    NOT_EQUAL(): TerminalNode;
    LT(): TerminalNode;
    LE(): TerminalNode;
    GE(): TerminalNode;
    GT(): TerminalNode;
    IN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RepeatStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    REPEAT(): TerminalNode;
    compoundStatement(): CompoundStatementContext;
    expression(): ExpressionContext;
    SEMI(): TerminalNode;
    UNTIL(): TerminalNode;
    MIENTRASQUE(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class RepetetiveStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    whileStatement(): WhileStatementContext;
    repeatStatement(): RepeatStatementContext;
    forStatement(): ForStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ResultTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    typeIdentifier(): TypeIdentifierContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ReturnStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    RETURN(): TerminalNode;
    SEMI(): TerminalNode;
    expression(): ExpressionContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class ScalarTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LPAREN(): TerminalNode;
    identifierList(): IdentifierListContext;
    RPAREN(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class Set_Context extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    LBRACK(): TerminalNode;
    elementList(): ElementListContext;
    RBRACK(): TerminalNode;
    LBRACK2(): TerminalNode;
    RBRACK2(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SetTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    SET(): TerminalNode;
    OF(): TerminalNode;
    baseType(): BaseTypeContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SignContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SignedFactorContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    factor(): FactorContext;
    PLUS(): TerminalNode;
    MINUS(): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SimpleExpressionContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    term(): TermContext;
    simpleExpression_list(): SimpleExpressionContext[];
    simpleExpression(i: number): SimpleExpressionContext;
    additiveoperator(): AdditiveoperatorContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SimpleStatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    assignmentStatement(): AssignmentStatementContext;
    procedureStatement(): ProcedureStatementContext;
    gotoStatement(): GotoStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class SimpleTypeContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    scalarType(): ScalarTypeContext;
    subrangeType(): SubrangeTypeContext;
    typeIdentifier(): TypeIdentifierContext;
    stringtype(): StringtypeContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class StatementContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    unlabelledStatement(): UnlabelledStatementContext;
    writeStatement(): WriteStatementContext;
    readStatement(): ReadStatementContext;
    breakStatement(): BreakStatementContext;
    continueStatement(): ContinueStatementContext;
    returnStatement(): ReturnStatementContext;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

declare class StatementsContext extends ParserRuleContext {
    constructor(parser?: StepCodeParser, parent?: ParserRuleContext, invokingState?: number);
    statement_list(): StatementContext[];
    statement(i: number): StatementContext;
    SEMI_list(): TerminalNode[];
    SEMI(i: number): TerminalNode;
    get ruleIndex(): number;
    enterRule(listener: StepCodeListener): void;
    exitRule(listener: StepCodeListener): void;
    accept<Result>(visitor: StepCodeVisitor<Result>): Result;
}

export declare class StepCodeError {
    readonly startLine: number;
    readonly startColumn: number;
    readonly endLine: number;
    readonly endColumn: number;
    readonly message: string;
    constructor({ startLine, startColumn, endLine, endColumn, message }: Props);
}

export declare class StepCodeInterpreter extends StepCodeVisitor<Promise<ReturnTypes>> {
    protected eventBus: EventBus;
    protected programState: Map<string, {
        type: ValidDataType;
        value: any;
    }>;
    protected availableSubprograms: Map<string, SubprogramContext>;
    static ARRAY_START: number;
    protected callStack: {
        identifier: string;
        variables: Map<string, {
            type: ValidDataType;
            value: any;
        }>;
    }[];
    protected get variables(): Map<string, {
        type: any;
        value: any;
    }>;
    constructor(eventBus: EventBus);
    visitChildren(node: StepCodeRuleNode): Promise<ReturnTypes>;
    start(ctx: ProgramContext): Promise<void>;
    visitDirectives: (ctx: DirectivesContext) => Promise<{
        identifier: string;
    }>;
    getIndexes(ctx: AccessorContext): AsyncGenerator<ReturnTypes, void, unknown>;
    visitVariable: (ctx: VariableContext) => Promise<{
        identifier: string;
        value: any;
        type: any;
    }>;
    visitString: (ctx: StringContext) => Promise<{
        readonly identifier: string;
        readonly value: string;
        readonly type: "string";
    }>;
    visitIdentifier: (ctx: IdentifierContext) => Promise<{
        identifier: string;
    }>;
    visitType_: (ctx: Type_Context) => Promise<{
        identifier: string;
    }>;
    visitVariableDeclaration: (ctx: VariableDeclarationContext) => Promise<{