@informalsystems/quint/dist/src/generated/EffectParser.d.ts

Core tool for the Quint specification language

import { ATN } from "antlr4ts/atn/ATN";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { EffectListener } from "./EffectListener";
import { EffectVisitor } from "./EffectVisitor";
export declare class EffectParser extends Parser {
    static readonly T__0 = 1;
    static readonly T__1 = 2;
    static readonly T__2 = 3;
    static readonly T__3 = 4;
    static readonly T__4 = 5;
    static readonly T__5 = 6;
    static readonly T__6 = 7;
    static readonly T__7 = 8;
    static readonly T__8 = 9;
    static readonly T__9 = 10;
    static readonly T__10 = 11;
    static readonly T__11 = 12;
    static readonly IDENTIFIER = 13;
    static readonly WS = 14;
    static readonly RULE_effect = 0;
    static readonly RULE_read = 1;
    static readonly RULE_update = 2;
    static readonly RULE_temporal = 3;
    static readonly RULE_concrete = 4;
    static readonly RULE_entity = 5;
    static readonly RULE_stateVarRef = 6;
    static readonly ruleNames: string[];
    private static readonly _LITERAL_NAMES;
    private static readonly _SYMBOLIC_NAMES;
    static readonly VOCABULARY: Vocabulary;
    get vocabulary(): Vocabulary;
    get grammarFileName(): string;
    get ruleNames(): string[];
    get serializedATN(): string;
    protected createFailedPredicateException(predicate?: string, message?: string): FailedPredicateException;
    constructor(input: TokenStream);
    effect(): EffectContext;
    read(): ReadContext;
    update(): UpdateContext;
    temporal(): TemporalContext;
    concrete(): ConcreteContext;
    entity(): EntityContext;
    stateVarRef(): StateVarRefContext;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class EffectContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: EffectContext): void;
}
export declare class ConcreteEffectContext extends EffectContext {
    concrete(): ConcreteContext;
    constructor(ctx: EffectContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class ArrowEffectContext extends EffectContext {
    effect(): EffectContext[];
    effect(i: number): EffectContext;
    constructor(ctx: EffectContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class VariableEffectContext extends EffectContext {
    IDENTIFIER(): TerminalNode;
    constructor(ctx: EffectContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class ReadContext extends ParserRuleContext {
    entity(): EntityContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class UpdateContext extends ParserRuleContext {
    entity(): EntityContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class TemporalContext extends ParserRuleContext {
    entity(): EntityContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class ConcreteContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ConcreteContext): void;
}
export declare class ReadOnlyContext extends ConcreteContext {
    read(): ReadContext;
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class UpdateOnlyContext extends ConcreteContext {
    update(): UpdateContext;
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class TemporalOnlyContext extends ConcreteContext {
    temporal(): TemporalContext;
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class ReadAndUpdateContext extends ConcreteContext {
    read(): ReadContext | undefined;
    update(): UpdateContext | undefined;
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class ReadAndTemporalContext extends ConcreteContext {
    read(): ReadContext | undefined;
    temporal(): TemporalContext | undefined;
    update(): UpdateContext | undefined;
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class PureContext extends ConcreteContext {
    constructor(ctx: ConcreteContext);
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class EntityContext extends ParserRuleContext {
    stateVarRef(): StateVarRefContext[];
    stateVarRef(i: number): StateVarRefContext;
    IDENTIFIER(): TerminalNode[];
    IDENTIFIER(i: number): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}
export declare class StateVarRefContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: EffectListener): void;
    exitRule(listener: EffectListener): void;
    accept<Result>(visitor: EffectVisitor<Result>): Result;
}