@synanetics/fhir-fml-convert/dist/generated/FhirMapperParser.d.ts

Converts StructureMaps written in FML to JSON ($convert operation)

import { ATN } from "antlr4ts/atn/ATN";
import { FailedPredicateException } from "antlr4ts/FailedPredicateException";
import { Parser } from "antlr4ts/Parser";
import { ParserRuleContext } from "antlr4ts/ParserRuleContext";
import { RuleContext } from "antlr4ts/RuleContext";
import { TerminalNode } from "antlr4ts/tree/TerminalNode";
import { TokenStream } from "antlr4ts/TokenStream";
import { Vocabulary } from "antlr4ts/Vocabulary";
import { FhirMapperListener } from "./FhirMapperListener";
import { FhirMapperVisitor } from "./FhirMapperVisitor";
export declare class FhirMapperParser 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 T__12 = 13;
    static readonly T__13 = 14;
    static readonly T__14 = 15;
    static readonly T__15 = 16;
    static readonly T__16 = 17;
    static readonly T__17 = 18;
    static readonly T__18 = 19;
    static readonly T__19 = 20;
    static readonly T__20 = 21;
    static readonly T__21 = 22;
    static readonly T__22 = 23;
    static readonly T__23 = 24;
    static readonly T__24 = 25;
    static readonly T__25 = 26;
    static readonly T__26 = 27;
    static readonly T__27 = 28;
    static readonly T__28 = 29;
    static readonly T__29 = 30;
    static readonly T__30 = 31;
    static readonly T__31 = 32;
    static readonly T__32 = 33;
    static readonly T__33 = 34;
    static readonly T__34 = 35;
    static readonly T__35 = 36;
    static readonly T__36 = 37;
    static readonly T__37 = 38;
    static readonly T__38 = 39;
    static readonly T__39 = 40;
    static readonly T__40 = 41;
    static readonly T__41 = 42;
    static readonly T__42 = 43;
    static readonly T__43 = 44;
    static readonly T__44 = 45;
    static readonly T__45 = 46;
    static readonly T__46 = 47;
    static readonly T__47 = 48;
    static readonly T__48 = 49;
    static readonly T__49 = 50;
    static readonly T__50 = 51;
    static readonly T__51 = 52;
    static readonly T__52 = 53;
    static readonly T__53 = 54;
    static readonly T__54 = 55;
    static readonly T__55 = 56;
    static readonly T__56 = 57;
    static readonly T__57 = 58;
    static readonly T__58 = 59;
    static readonly T__59 = 60;
    static readonly T__60 = 61;
    static readonly T__61 = 62;
    static readonly T__62 = 63;
    static readonly T__63 = 64;
    static readonly T__64 = 65;
    static readonly T__65 = 66;
    static readonly T__66 = 67;
    static readonly T__67 = 68;
    static readonly T__68 = 69;
    static readonly T__69 = 70;
    static readonly T__70 = 71;
    static readonly T__71 = 72;
    static readonly T__72 = 73;
    static readonly T__73 = 74;
    static readonly T__74 = 75;
    static readonly T__75 = 76;
    static readonly T__76 = 77;
    static readonly T__77 = 78;
    static readonly T__78 = 79;
    static readonly T__79 = 80;
    static readonly T__80 = 81;
    static readonly T__81 = 82;
    static readonly T__82 = 83;
    static readonly T__83 = 84;
    static readonly T__84 = 85;
    static readonly T__85 = 86;
    static readonly BOOL = 87;
    static readonly QUOTEDIDENTIFIER = 88;
    static readonly INTEGER = 89;
    static readonly STRING = 90;
    static readonly NUMBER = 91;
    static readonly DATE = 92;
    static readonly DATETIME = 93;
    static readonly TIME = 94;
    static readonly IDENTIFIER = 95;
    static readonly DELIMITEDIDENTIFIER = 96;
    static readonly WS = 97;
    static readonly COMMENT = 98;
    static readonly LINE_COMMENT = 99;
    static readonly RULE_structureMap = 0;
    static readonly RULE_metadata = 1;
    static readonly RULE_metadataKey = 2;
    static readonly RULE_metadataValue = 3;
    static readonly RULE_mapId = 4;
    static readonly RULE_mapAlias = 5;
    static readonly RULE_url = 6;
    static readonly RULE_variableId = 7;
    static readonly RULE_structure = 8;
    static readonly RULE_structureAlias = 9;
    static readonly RULE_imports = 10;
    static readonly RULE_constRule = 11;
    static readonly RULE_group = 12;
    static readonly RULE_rules = 13;
    static readonly RULE_typeMode = 14;
    static readonly RULE_extendsRule = 15;
    static readonly RULE_parameters = 16;
    static readonly RULE_parameter = 17;
    static readonly RULE_type = 18;
    static readonly RULE_ruleDefinition = 19;
    static readonly RULE_ruleName = 20;
    static readonly RULE_ruleSources = 21;
    static readonly RULE_ruleSource = 22;
    static readonly RULE_ruleTargets = 23;
    static readonly RULE_sourceType = 24;
    static readonly RULE_sourceCardinality = 25;
    static readonly RULE_upperBound = 26;
    static readonly RULE_ruleCtx = 27;
    static readonly RULE_sourceDefault = 28;
    static readonly RULE_alias = 29;
    static readonly RULE_whereClause = 30;
    static readonly RULE_evaluateTransform = 31;
    static readonly RULE_checkClause = 32;
    static readonly RULE_log = 33;
    static readonly RULE_dependent = 34;
    static readonly RULE_ruleTarget = 35;
    static readonly RULE_transform = 36;
    static readonly RULE_namedInvocation = 37;
    static readonly RULE_paramList = 38;
    static readonly RULE_param = 39;
    static readonly RULE_fhirPath = 40;
    static readonly RULE_literal = 41;
    static readonly RULE_groupTypeMode = 42;
    static readonly RULE_sourceListMode = 43;
    static readonly RULE_targetListMode = 44;
    static readonly RULE_inputMode = 45;
    static readonly RULE_modelMode = 46;
    static readonly RULE_markdown = 47;
    static readonly RULE_expression = 48;
    static readonly RULE_term = 49;
    static readonly RULE_externalConstant = 50;
    static readonly RULE_invocation = 51;
    static readonly RULE_function = 52;
    static readonly RULE_quantity = 53;
    static readonly RULE_unit = 54;
    static readonly RULE_dateTimePrecision = 55;
    static readonly RULE_pluralDateTimePrecision = 56;
    static readonly RULE_typeSpecifier = 57;
    static readonly RULE_qualifiedIdentifier = 58;
    static readonly RULE_identifier = 59;
    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);
    structureMap(): StructureMapContext;
    metadata(): MetadataContext;
    metadataKey(): MetadataKeyContext;
    metadataValue(): MetadataValueContext;
    mapId(): MapIdContext;
    mapAlias(): MapAliasContext;
    url(): UrlContext;
    variableId(): VariableIdContext;
    structure(): StructureContext;
    structureAlias(): StructureAliasContext;
    imports(): ImportsContext;
    constRule(): ConstRuleContext;
    group(): GroupContext;
    rules(): RulesContext;
    typeMode(): TypeModeContext;
    extendsRule(): ExtendsRuleContext;
    parameters(): ParametersContext;
    parameter(): ParameterContext;
    type(): TypeContext;
    ruleDefinition(): RuleDefinitionContext;
    ruleName(): RuleNameContext;
    ruleSources(): RuleSourcesContext;
    ruleSource(): RuleSourceContext;
    ruleTargets(): RuleTargetsContext;
    sourceType(): SourceTypeContext;
    sourceCardinality(): SourceCardinalityContext;
    upperBound(): UpperBoundContext;
    ruleCtx(): RuleCtxContext;
    sourceDefault(): SourceDefaultContext;
    alias(): AliasContext;
    whereClause(): WhereClauseContext;
    evaluateTransform(): EvaluateTransformContext;
    checkClause(): CheckClauseContext;
    log(): LogContext;
    dependent(): DependentContext;
    ruleTarget(): RuleTargetContext;
    transform(): TransformContext;
    namedInvocation(): NamedInvocationContext;
    paramList(): ParamListContext;
    param(): ParamContext;
    fhirPath(): FhirPathContext;
    literal(): LiteralContext;
    groupTypeMode(): GroupTypeModeContext;
    sourceListMode(): SourceListModeContext;
    targetListMode(): TargetListModeContext;
    inputMode(): InputModeContext;
    modelMode(): ModelModeContext;
    markdown(): MarkdownContext;
    expression(): ExpressionContext;
    expression(_p: number): ExpressionContext;
    term(): TermContext;
    externalConstant(): ExternalConstantContext;
    invocation(): InvocationContext;
    function(): FunctionContext;
    quantity(): QuantityContext;
    unit(): UnitContext;
    dateTimePrecision(): DateTimePrecisionContext;
    pluralDateTimePrecision(): PluralDateTimePrecisionContext;
    typeSpecifier(): TypeSpecifierContext;
    qualifiedIdentifier(): QualifiedIdentifierContext;
    identifier(): IdentifierContext;
    sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean;
    private expression_sempred;
    static readonly _serializedATN: string;
    static __ATN: ATN;
    static get _ATN(): ATN;
}
export declare class StructureMapContext extends ParserRuleContext {
    mapId(): MapIdContext;
    EOF(): TerminalNode;
    metadata(): MetadataContext[];
    metadata(i: number): MetadataContext;
    structure(): StructureContext[];
    structure(i: number): StructureContext;
    imports(): ImportsContext[];
    imports(i: number): ImportsContext;
    constRule(): ConstRuleContext[];
    constRule(i: number): ConstRuleContext;
    group(): GroupContext[];
    group(i: number): GroupContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MetadataContext extends ParserRuleContext {
    metadataKey(): MetadataKeyContext;
    metadataValue(): MetadataValueContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MetadataKeyContext extends ParserRuleContext {
    variableId(): VariableIdContext[];
    variableId(i: number): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MetadataValueContext extends ParserRuleContext {
    literal(): LiteralContext | undefined;
    markdown(): MarkdownContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MapIdContext extends ParserRuleContext {
    url(): UrlContext;
    mapAlias(): MapAliasContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MapAliasContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class UrlContext extends ParserRuleContext {
    QUOTEDIDENTIFIER(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class VariableIdContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    QUOTEDIDENTIFIER(): TerminalNode | undefined;
    DELIMITEDIDENTIFIER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class StructureContext extends ParserRuleContext {
    url(): UrlContext;
    modelMode(): ModelModeContext;
    structureAlias(): StructureAliasContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class StructureAliasContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ImportsContext extends ParserRuleContext {
    url(): UrlContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ConstRuleContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class GroupContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    parameters(): ParametersContext;
    rules(): RulesContext;
    extendsRule(): ExtendsRuleContext | undefined;
    typeMode(): TypeModeContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RulesContext extends ParserRuleContext {
    ruleDefinition(): RuleDefinitionContext[];
    ruleDefinition(i: number): RuleDefinitionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TypeModeContext extends ParserRuleContext {
    groupTypeMode(): GroupTypeModeContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ExtendsRuleContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ParametersContext extends ParserRuleContext {
    parameter(): ParameterContext[];
    parameter(i: number): ParameterContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ParameterContext extends ParserRuleContext {
    inputMode(): InputModeContext;
    variableId(): VariableIdContext;
    type(): TypeContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TypeContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleDefinitionContext extends ParserRuleContext {
    ruleSources(): RuleSourcesContext;
    ruleTargets(): RuleTargetsContext | undefined;
    dependent(): DependentContext | undefined;
    ruleName(): RuleNameContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleNameContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleSourcesContext extends ParserRuleContext {
    ruleSource(): RuleSourceContext[];
    ruleSource(i: number): RuleSourceContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleSourceContext extends ParserRuleContext {
    ruleCtx(): RuleCtxContext;
    sourceType(): SourceTypeContext | undefined;
    sourceCardinality(): SourceCardinalityContext | undefined;
    sourceDefault(): SourceDefaultContext | undefined;
    sourceListMode(): SourceListModeContext | undefined;
    alias(): AliasContext | undefined;
    whereClause(): WhereClauseContext | undefined;
    checkClause(): CheckClauseContext | undefined;
    log(): LogContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleTargetsContext extends ParserRuleContext {
    ruleTarget(): RuleTargetContext[];
    ruleTarget(i: number): RuleTargetContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class SourceTypeContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class SourceCardinalityContext extends ParserRuleContext {
    INTEGER(): TerminalNode;
    upperBound(): UpperBoundContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class UpperBoundContext extends ParserRuleContext {
    INTEGER(): TerminalNode;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleCtxContext extends ParserRuleContext {
    variableId(): VariableIdContext[];
    variableId(i: number): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class SourceDefaultContext extends ParserRuleContext {
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class AliasContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class WhereClauseContext extends ParserRuleContext {
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class EvaluateTransformContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class CheckClauseContext extends ParserRuleContext {
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class LogContext extends ParserRuleContext {
    fhirPath(): FhirPathContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class DependentContext extends ParserRuleContext {
    namedInvocation(): NamedInvocationContext[];
    namedInvocation(i: number): NamedInvocationContext;
    rules(): RulesContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class RuleTargetContext extends ParserRuleContext {
    ruleCtx(): RuleCtxContext | undefined;
    transform(): TransformContext | undefined;
    alias(): AliasContext | undefined;
    targetListMode(): TargetListModeContext | undefined;
    namedInvocation(): NamedInvocationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TransformContext extends ParserRuleContext {
    literal(): LiteralContext | undefined;
    ruleCtx(): RuleCtxContext | undefined;
    evaluateTransform(): EvaluateTransformContext | undefined;
    namedInvocation(): NamedInvocationContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class NamedInvocationContext extends ParserRuleContext {
    variableId(): VariableIdContext;
    paramList(): ParamListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ParamListContext extends ParserRuleContext {
    param(): ParamContext[];
    param(i: number): ParamContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ParamContext extends ParserRuleContext {
    literal(): LiteralContext | undefined;
    variableId(): VariableIdContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class FhirPathContext extends ParserRuleContext {
    expression(): ExpressionContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class LiteralContext extends ParserRuleContext {
    INTEGER(): TerminalNode | undefined;
    NUMBER(): TerminalNode | undefined;
    STRING(): TerminalNode | undefined;
    DATETIME(): TerminalNode | undefined;
    DATE(): TerminalNode | undefined;
    TIME(): TerminalNode | undefined;
    BOOL(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class GroupTypeModeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class SourceListModeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TargetListModeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class InputModeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ModelModeContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MarkdownContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ExpressionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: ExpressionContext): void;
}
export declare class TermExpressionContext extends ExpressionContext {
    term(): TermContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class InvocationExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    invocation(): InvocationContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class IndexerExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class PolarityExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MultiplicativeExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class AdditiveExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TypeExpressionContext extends ExpressionContext {
    expression(): ExpressionContext;
    typeSpecifier(): TypeSpecifierContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class UnionExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class InequalityExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class EqualityExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class MembershipExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class AndExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class OrExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ImpliesExpressionContext extends ExpressionContext {
    expression(): ExpressionContext[];
    expression(i: number): ExpressionContext;
    constructor(ctx: ExpressionContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TermContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: TermContext): void;
}
export declare class InvocationTermContext extends TermContext {
    invocation(): InvocationContext;
    constructor(ctx: TermContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class LiteralTermContext extends TermContext {
    literal(): LiteralContext;
    constructor(ctx: TermContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ExternalConstantTermContext extends TermContext {
    externalConstant(): ExternalConstantContext;
    constructor(ctx: TermContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ParenthesizedTermContext extends TermContext {
    expression(): ExpressionContext;
    constructor(ctx: TermContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ExternalConstantContext extends ParserRuleContext {
    identifier(): IdentifierContext | undefined;
    STRING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class InvocationContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    copyFrom(ctx: InvocationContext): void;
}
export declare class MemberInvocationContext extends InvocationContext {
    identifier(): IdentifierContext;
    constructor(ctx: InvocationContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class FunctionInvocationContext extends InvocationContext {
    function(): FunctionContext;
    constructor(ctx: InvocationContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class ThisInvocationContext extends InvocationContext {
    constructor(ctx: InvocationContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class IndexInvocationContext extends InvocationContext {
    constructor(ctx: InvocationContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TotalInvocationContext extends InvocationContext {
    constructor(ctx: InvocationContext);
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class FunctionContext extends ParserRuleContext {
    identifier(): IdentifierContext;
    paramList(): ParamListContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class QuantityContext extends ParserRuleContext {
    NUMBER(): TerminalNode;
    unit(): UnitContext | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class UnitContext extends ParserRuleContext {
    dateTimePrecision(): DateTimePrecisionContext | undefined;
    pluralDateTimePrecision(): PluralDateTimePrecisionContext | undefined;
    STRING(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class DateTimePrecisionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class PluralDateTimePrecisionContext extends ParserRuleContext {
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class TypeSpecifierContext extends ParserRuleContext {
    qualifiedIdentifier(): QualifiedIdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class QualifiedIdentifierContext extends ParserRuleContext {
    identifier(): IdentifierContext[];
    identifier(i: number): IdentifierContext;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
export declare class IdentifierContext extends ParserRuleContext {
    IDENTIFIER(): TerminalNode | undefined;
    DELIMITEDIDENTIFIER(): TerminalNode | undefined;
    constructor(parent: ParserRuleContext | undefined, invokingState: number);
    get ruleIndex(): number;
    enterRule(listener: FhirMapperListener): void;
    exitRule(listener: FhirMapperListener): void;
    accept<Result>(visitor: FhirMapperVisitor<Result>): Result;
}
//# sourceMappingURL=FhirMapperParser.d.ts.map