Variable sparql12ParserBuilderConst

sparql12ParserBuilder: ParserBuilder<
    SparqlContext,
    | "string"
    | "object"
    | "filter"
    | "add"
    | "clear"
    | "copy"
    | "move"
    | "var"
    | "path"
    | "annotation"
    | "drop"
    | "load"
    | "builtInStr"
    | "builtInLang"
    | "builtInLangmatches"
    | "builtInDatatype"
    | "builtInBound"
    | "builtInIri"
    | "builtInUri"
    | "builtInBnode"
    | "builtInRand"
    | "builtInAbs"
    | "builtInCeil"
    | "builtInFloor"
    | "builtInRound"
    | "builtInConcat"
    | "builtInStrlen"
    | "builtInUcase"
    | "builtInLcase"
    | "builtInEncode_for_uri"
    | "builtInContains"
    | "builtInStrstarts"
    | "builtInStrends"
    | "builtInStrbefore"
    | "builtInStrafter"
    | "builtInYear"
    | "builtInMonth"
    | "builtInDay"
    | "builtInHours"
    | "builtInMinutes"
    | "builtInSeconds"
    | "builtInTimezone"
    | "builtInTz"
    | "builtInNow"
    | "builtInUuid"
    | "builtInStruuid"
    | "builtInMd5"
    | "builtInSha1"
    | "builtInSha256"
    | "builtInSha384"
    | "builtInSha512"
    | "builtInCoalesce"
    | "builtInIf"
    | "builtInStrlang"
    | "builtInStrdt"
    | "builtInSameterm"
    | "builtInIsiri"
    | "builtInIsuri"
    | "builtInIsblank"
    | "builtInIsliteral"
    | "builtInIsnumeric"
    | "builtInRegex"
    | "builtInSubstr"
    | "builtInReplace"
    | "builtInExists"
    | "builtInNotexists"
    | "builtInCount"
    | "builtInSum"
    | "builtInMin"
    | "builtInMax"
    | "builtInAvg"
    | "builtInSample"
    | "builtInGroup_concat"
    | "quads"
    | "functionCall"
    | "create"
    | "bind"
    | "aggregate"
    | "rdfLiteral"
    | "iri"
    | "numericLiteral"
    | "numericLiteralUnsigned"
    | "numericLiteralPositive"
    | "numericLiteralNegative"
    | "booleanLiteral"
    | "prefixedName"
    | "blankNode"
    | "datasetClause"
    | "defaultGraphClause"
    | "namedGraphClause"
    | "sourceSelector"
    | "prologue"
    | "baseDecl"
    | "prefixDecl"
    | "verb"
    | "varOrIri"
    | "VerbA"
    | "varOrTerm"
    | "pathAlternative"
    | "pathSequence"
    | "pathEltOrInverse"
    | "pathElt"
    | "pathMod"
    | "pathPrimary"
    | "pathNegatedPropertySet"
    | "pathOneInPropertySet"
    | "triplesBlock"
    | "triplesSameSubjectPath"
    | "propertyListPathNotEmpty"
    | "propertyListNotEmpty"
    | "propertyListPath"
    | "propertyList"
    | "triplesNodePath"
    | "triplesNode"
    | "triplesSameSubject"
    | "triplesTemplate"
    | "verbPath"
    | "verbSimple"
    | "objectList"
    | "objectListPath"
    | "graphNodePath"
    | "graphNode"
    | "objectPath"
    | "collection"
    | "blankNodePropertyList"
    | "collectionPath"
    | "blankNodePropertyListPath"
    | "whereClause"
    | "groupGraphPattern"
    | "subSelect"
    | "groupGraphPatternSub"
    | "graphPatternNotTriples"
    | "groupOrUnionGraphPattern"
    | "optionalGraphPattern"
    | "minusGraphPattern"
    | "graphGraphPattern"
    | "serviceGraphPattern"
    | "inlineData"
    | "expression"
    | "valuesClause"
    | "dataBlock"
    | "inlineDataOneVar"
    | "inlineDataFull"
    | "dataBlockValue"
    | "constraint"
    | "brackettedExpression"
    | "builtInCall"
    | "argList"
    | "expressionList"
    | "conditionalOrExpression"
    | "iriOrFunction"
    | "conditionalAndExpression"
    | "valueLogical"
    | "relationalExpression"
    | "numericExpression"
    | "additiveExpression"
    | "multiplicativeExpression"
    | "unaryExpression"
    | "primaryExpression"
    | "solutionModifier"
    | "limitOffsetClauses"
    | "groupClause"
    | "havingClause"
    | "orderClause"
    | "groupCondition"
    | "havingCondition"
    | "orderCondition"
    | "limitClause"
    | "offsetClause"
    | "selectQuery"
    | "constructQuery"
    | "describeQuery"
    | "askQuery"
    | "selectClause"
    | "constructTemplate"
    | "constructTriples"
    | "update1"
    | "insertData"
    | "deleteData"
    | "deleteWhere"
    | "modify"
    | "graphRef"
    | "graphRefAll"
    | "graphOrDefault"
    | "quadData"
    | "quadPattern"
    | "deleteClause"
    | "insertClause"
    | "usingClause"
    | "quadsNotTriples"
    | "reifiedTriple"
    | "reifiedTripleBlock"
    | "reifiedTripleBlockPath"
    | "tripleTermData"
    | "reifier"
    | "varOrReifierId"
    | "annotationPath"
    | "annotationBlockPath"
    | "annotationBlock"
    | "tripleTerm"
    | "reifiedTripleSubject"
    | "reifiedTripleObject"
    | "tripleTermSubject"
    | "tripleTermObject"
    | "tripleTermDataSubject"
    | "tripleTermDataObject"
    | "exprTripleTerm"
    | "exprTripleTermSubject"
    | "exprTripleTermObject"
    | "builtInLangdir"
    | "builtInStrLangdir"
    | "builtInHasLang"
    | "builtInHasLangdir"
    | "builtInIsTriple"
    | "builtInTriple"
    | "builtInSubject"
    | "builtInPredicate"
    | "builtInObject"
    | "queryOrUpdate",
    {
        add: ParserRule<
            SparqlContext,
            "add",
            CopyMoveAddOperation & { type: "add" },
            undefined,
        >;
        additiveExpression: ParserRule<
            SparqlContext,
            "additiveExpression",
            types.Expression,
            undefined,
        >;
        aggregate: ParserRule<
            SparqlContext,
            "aggregate",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        annotation: ParserRule<any, "annotation"> & SparqlGrammarRule<
            "annotation",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >[],
            undefined,
        >;
        annotationBlock: ParserRule<any, "annotationBlock"> & SparqlGrammarRule<
            "annotationBlock",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<
                Patch<Triple, { object: types.Term; subject: types.Term }>,
                "subject",
            >,
        >;
        annotationBlockPath: ParserRule<any, "annotationBlockPath"> & SparqlGrammarRule<
            "annotationBlockPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<
                Patch<Triple, { object: types.Term; subject: types.Term }>,
                "subject",
            >,
        >;
        annotationPath: ParserRule<any, "annotationPath"> & SparqlGrammarRule<
            "annotationPath",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >[],
            undefined,
        >;
        argList: ParserRule<
            SparqlContext,
            "argList",
            Patch<IArgList, { args: types.Expression[] }>,
            undefined,
        >;
        askQuery: ParserRule<
            SparqlContext,
            "askQuery",
            Omit<
                Patch<
                    AskQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                HandledByBase,
            >,
            undefined,
        >;
        baseDecl: ParserRule<any, "baseDecl"> & SparqlGrammarRule<
            "baseDecl",
            string,
        >;
        bind: ParserRule<
            SparqlContext,
            "bind",
            Patch<BindPattern, { expression: types.Expression }>,
            undefined,
        >;
        blankNode: ParserRule<any, "blankNode"> & ParserRule<
            SparqlContext,
            "blankNode",
            BlankNode,
            undefined,
        > & GeneratorRule<undefined, "blankNode", BlankNode, undefined>;
        blankNodePropertyList: ParserRule<
            SparqlContext,
            "blankNodePropertyList",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        blankNodePropertyListPath: ParserRule<
            SparqlContext,
            "blankNodePropertyListPath",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        booleanLiteral: ParserRule<
            SparqlContext,
            "booleanLiteral",
            Literal,
            undefined,
        >;
        brackettedExpression: ParserRule<
            SparqlContext,
            "brackettedExpression",
            types.Expression,
            undefined,
        >;
        builtInAbs: ParserRule<
            SparqlContext,
            "builtInAbs",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInAvg: ParserRule<
            SparqlContext,
            "builtInAvg",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInBnode: ParserRule<
            SparqlContext,
            "builtInBnode",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInBound: ParserRule<
            SparqlContext,
            "builtInBound",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInCall: ParserRule<
            SparqlContext,
            "builtInCall",
            Expression,
            undefined,
        >;
        builtInCeil: ParserRule<
            SparqlContext,
            "builtInCeil",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInCoalesce: ParserRule<
            SparqlContext,
            "builtInCoalesce",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInConcat: ParserRule<
            SparqlContext,
            "builtInConcat",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInContains: ParserRule<
            SparqlContext,
            "builtInContains",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInCount: ParserRule<
            SparqlContext,
            "builtInCount",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInDatatype: ParserRule<
            SparqlContext,
            "builtInDatatype",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInDay: ParserRule<
            SparqlContext,
            "builtInDay",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInEncode_for_uri: ParserRule<
            SparqlContext,
            "builtInEncode_for_uri",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInExists: ParserRule<
            SparqlContext,
            "builtInExists",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInFloor: ParserRule<
            SparqlContext,
            "builtInFloor",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInGroup_concat: ParserRule<
            SparqlContext,
            "builtInGroup_concat",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInHasLang: ParserRule<any, "builtInHasLang"> & RuleDefExpressionFunctionX<
            "builtInHasLang",
            [Expression],
        >;
        builtInHasLangdir: ParserRule<any, "builtInHasLangdir"> & RuleDefExpressionFunctionX<
            "builtInHasLangdir",
            [Expression],
        >;
        builtInHours: ParserRule<
            SparqlContext,
            "builtInHours",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIf: ParserRule<
            SparqlContext,
            "builtInIf",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIri: ParserRule<
            SparqlContext,
            "builtInIri",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIsblank: ParserRule<
            SparqlContext,
            "builtInIsblank",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIsiri: ParserRule<
            SparqlContext,
            "builtInIsiri",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIsliteral: ParserRule<
            SparqlContext,
            "builtInIsliteral",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIsnumeric: ParserRule<
            SparqlContext,
            "builtInIsnumeric",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInIsTriple: ParserRule<any, "builtInIsTriple"> & RuleDefExpressionFunctionX<
            "builtInIsTriple",
            [Expression],
        >;
        builtInIsuri: ParserRule<
            SparqlContext,
            "builtInIsuri",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInLang: ParserRule<
            SparqlContext,
            "builtInLang",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInLangdir: ParserRule<any, "builtInLangdir"> & RuleDefExpressionFunctionX<
            "builtInLangdir",
            [Expression],
        >;
        builtInLangmatches: ParserRule<
            SparqlContext,
            "builtInLangmatches",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInLcase: ParserRule<
            SparqlContext,
            "builtInLcase",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInMax: ParserRule<
            SparqlContext,
            "builtInMax",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInMd5: ParserRule<
            SparqlContext,
            "builtInMd5",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInMin: ParserRule<
            SparqlContext,
            "builtInMin",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInMinutes: ParserRule<
            SparqlContext,
            "builtInMinutes",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInMonth: ParserRule<
            SparqlContext,
            "builtInMonth",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInNotexists: ParserRule<
            SparqlContext,
            "builtInNotexists",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInNow: ParserRule<
            SparqlContext,
            "builtInNow",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInObject: ParserRule<any, "builtInObject"> & RuleDefExpressionFunctionX<
            "builtInObject",
            [Expression],
        >;
        builtInPredicate: ParserRule<any, "builtInPredicate"> & RuleDefExpressionFunctionX<
            "builtInPredicate",
            [Expression],
        >;
        builtInRand: ParserRule<
            SparqlContext,
            "builtInRand",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInRegex: ParserRule<any, "builtInRegex"> & RuleDefExpressionFunctionX<
            "builtInRegex",
            [Expression, Expression]
            | [Expression, Expression, Expression],
        >;
        builtInReplace: ParserRule<
            SparqlContext,
            "builtInReplace",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInRound: ParserRule<
            SparqlContext,
            "builtInRound",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSameterm: ParserRule<
            SparqlContext,
            "builtInSameterm",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSample: ParserRule<
            SparqlContext,
            "builtInSample",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInSeconds: ParserRule<
            SparqlContext,
            "builtInSeconds",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSha1: ParserRule<
            SparqlContext,
            "builtInSha1",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSha256: ParserRule<
            SparqlContext,
            "builtInSha256",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSha384: ParserRule<
            SparqlContext,
            "builtInSha384",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSha512: ParserRule<
            SparqlContext,
            "builtInSha512",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStr: ParserRule<
            SparqlContext,
            "builtInStr",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrafter: ParserRule<
            SparqlContext,
            "builtInStrafter",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrbefore: ParserRule<
            SparqlContext,
            "builtInStrbefore",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrdt: ParserRule<
            SparqlContext,
            "builtInStrdt",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrends: ParserRule<
            SparqlContext,
            "builtInStrends",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrlang: ParserRule<
            SparqlContext,
            "builtInStrlang",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrLangdir: ParserRule<any, "builtInStrLangdir"> & RuleDefExpressionFunctionX<
            "builtInStrLangdir",
            [Expression, Expression, Expression],
        >;
        builtInStrlen: ParserRule<
            SparqlContext,
            "builtInStrlen",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStrstarts: ParserRule<
            SparqlContext,
            "builtInStrstarts",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInStruuid: ParserRule<
            SparqlContext,
            "builtInStruuid",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSubject: ParserRule<any, "builtInSubject"> & RuleDefExpressionFunctionX<
            "builtInSubject",
            [Expression],
        >;
        builtInSubstr: ParserRule<
            SparqlContext,
            "builtInSubstr",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInSum: ParserRule<
            SparqlContext,
            "builtInSum",
            Patch<
                AggregateExpression,
                BaseExpression & { expression: Wildcard
                | types.Expression },
            >,
            undefined,
        >;
        builtInTimezone: ParserRule<
            SparqlContext,
            "builtInTimezone",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInTriple: ParserRule<any, "builtInTriple"> & RuleDefExpressionFunctionX<
            "builtInTriple",
            [Expression, Expression, Expression],
        >;
        builtInTz: ParserRule<
            SparqlContext,
            "builtInTz",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInUcase: ParserRule<
            SparqlContext,
            "builtInUcase",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInUri: ParserRule<
            SparqlContext,
            "builtInUri",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInUuid: ParserRule<
            SparqlContext,
            "builtInUuid",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        builtInYear: ParserRule<
            SparqlContext,
            "builtInYear",
            Patch<
                OperationExpression,
                BaseExpression & { args: types.Expression[]
                | [types.Pattern] },
            >,
            undefined,
        >;
        clear: ParserRule<SparqlContext, "clear", ClearDropOperation, undefined>;
        collection: ParserRule<
            SparqlContext,
            "collection",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        collectionPath: ParserRule<
            SparqlContext,
            "collectionPath",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        conditionalAndExpression: ParserRule<
            SparqlContext,
            "conditionalAndExpression",
            types.Expression,
            undefined,
        >;
        conditionalOrExpression: ParserRule<
            SparqlContext,
            "conditionalOrExpression",
            types.Expression,
            undefined,
        >;
        constraint: ParserRule<
            SparqlContext,
            "constraint",
            types.Expression,
            undefined,
        >;
        constructQuery: ParserRule<
            SparqlContext,
            "constructQuery",
            Omit<
                Patch<
                    ConstructQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<(...), (...)>[];
                            having?: types.Expression[];
                            order: undefined | Patch<(...), (...)>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    > & { template?: Patch<Triple, { object: ...; subject: ... }>[] },
                >,
                HandledByBase,
            >,
            undefined,
        >;
        constructTemplate: ParserRule<
            SparqlContext,
            "constructTemplate",
            undefined
            | Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        constructTriples: ParserRule<
            SparqlContext,
            "constructTriples",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        copy: ParserRule<
            SparqlContext,
            "copy",
            CopyMoveAddOperation & { type: "copy" },
            undefined,
        >;
        create: ParserRule<SparqlContext, "create", CreateOperation, undefined>;
        dataBlock: ParserRule<
            SparqlContext,
            "dataBlock",
            types.ValuePatternRow[],
            undefined,
        >;
        dataBlockValue: ParserRule<
            SparqlContext,
            "dataBlockValue",
            undefined
            | BlankNode
            | Literal
            | IriTerm
            | types.BaseQuadTerm,
            undefined,
        >;
        datasetClause: ParserRule<
            SparqlContext,
            "datasetClause",
            IDatasetClause,
            undefined,
        >;
        defaultGraphClause: ParserRule<
            SparqlContext,
            "defaultGraphClause",
            types.IriTerm<string>,
            undefined,
        >;
        deleteClause: ParserRule<
            SparqlContext,
            "deleteClause",
            types.Quads,
            undefined,
        >;
        deleteData: ParserRule<
            SparqlContext,
            "deleteData",
            Patch<DeleteOperation, { delete: types.Quads[] }>,
            undefined,
        >;
        deleteWhere: ParserRule<
            SparqlContext,
            "deleteWhere",
            Patch<DeleteWhereOperation, { delete: types.Quads[] }>,
            undefined,
        >;
        describeQuery: ParserRule<
            SparqlContext,
            "describeQuery",
            Omit<
                Patch<
                    DescribeQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                HandledByBase,
            >,
            undefined,
        >;
        drop: ParserRule<SparqlContext, "drop", ClearDropOperation, undefined>;
        expression: ParserRule<
            SparqlContext,
            "expression",
            types.Expression,
            undefined,
        >;
        expressionList: ParserRule<
            SparqlContext,
            "expressionList",
            types.Expression[],
            undefined,
        >;
        exprTripleTerm: ParserRule<any, "exprTripleTerm"> & SparqlGrammarRule<
            "exprTripleTerm",
            types.BaseQuadTerm,
            undefined,
        >;
        exprTripleTermObject: ParserRule<any, "exprTripleTermObject"> & SparqlGrammarRule<
            "exprTripleTermObject",
            Literal
            | Variable
            | IriTerm<string>
            | types.BaseQuadTerm,
            undefined,
        >;
        exprTripleTermSubject: ParserRule<any, "exprTripleTermSubject"> & SparqlGrammarRule<
            "exprTripleTermSubject",
            Literal
            | Variable
            | IriTerm<string>,
            undefined,
        >;
        filter: ParserRule<
            SparqlContext,
            "filter",
            Patch<FilterPattern, { expression: types.Expression }>,
            undefined,
        >;
        functionCall: ParserRule<
            SparqlContext,
            "functionCall",
            Patch<FunctionCallExpression, { args: types.Expression[] }>,
            undefined,
        >;
        graphGraphPattern: ParserRule<
            SparqlContext,
            "graphGraphPattern",
            Patch<GraphPattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        graphNode: ParserRule<
            SparqlContext,
            "graphNode",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        graphNodePath: ParserRule<
            SparqlContext,
            "graphNodePath",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        graphOrDefault: ParserRule<
            SparqlContext,
            "graphOrDefault",
            GraphOrDefault,
            undefined,
        >;
        graphPatternNotTriples: ParserRule<
            SparqlContext,
            "graphPatternNotTriples",
            | types.BlockPattern
            | Patch<FilterPattern, { expression: types.Expression }>
            | Patch<BindPattern, { expression: types.Expression }>
            | Patch<ValuesPattern, { values: types.ValuePatternRow[] }>,
            undefined,
        >;
        graphRef: ParserRule<
            SparqlContext,
            "graphRef",
            types.IriTerm<string>,
            undefined,
        >;
        graphRefAll: ParserRule<
            SparqlContext,
            "graphRefAll",
            GraphReference,
            undefined,
        >;
        groupClause: ParserRule<
            SparqlContext,
            "groupClause",
            Patch<Grouping, { expression: types.Expression }>[],
            undefined,
        >;
        groupCondition: ParserRule<
            SparqlContext,
            "groupCondition",
            Patch<Grouping, { expression: types.Expression }>,
            undefined,
        >;
        groupGraphPattern: ParserRule<
            SparqlContext,
            "groupGraphPattern",
            Patch<GroupPattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        groupGraphPatternSub: ParserRule<
            SparqlContext,
            "groupGraphPatternSub",
            types.Pattern[],
            undefined,
        >;
        groupOrUnionGraphPattern: ParserRule<
            SparqlContext,
            "groupOrUnionGraphPattern",
            | Patch<UnionPattern, { patterns: types.Pattern[] }>
            | Patch<GroupPattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        havingClause: ParserRule<
            SparqlContext,
            "havingClause",
            types.Expression[],
            undefined,
        >;
        havingCondition: ParserRule<
            SparqlContext,
            "havingCondition",
            types.Expression,
            undefined,
        >;
        inlineData: ParserRule<
            SparqlContext,
            "inlineData",
            Patch<ValuesPattern, { values: types.ValuePatternRow[] }>,
            undefined,
        >;
        inlineDataFull: ParserRule<
            SparqlContext,
            "inlineDataFull",
            types.ValuePatternRow[],
            undefined,
        >;
        inlineDataOneVar: ParserRule<
            SparqlContext,
            "inlineDataOneVar",
            types.ValuePatternRow[],
            undefined,
        >;
        insertClause: ParserRule<
            SparqlContext,
            "insertClause",
            types.Quads,
            undefined,
        >;
        insertData: ParserRule<
            SparqlContext,
            "insertData",
            Patch<InsertOperation, { insert: types.Quads[] }>,
            undefined,
        >;
        iri: ParserRule<any, "iri"> & ParserRule<
            SparqlContext,
            "iri",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "iri", IriTerm, undefined>;
        iriOrFunction: ParserRule<
            SparqlContext,
            "iriOrFunction",
            | types.IriTerm<string>
            | Patch<IArgList, { args: types.Expression[] }> & {
                function: types.IriTerm;
            },
            undefined,
        >;
        limitClause: ParserRule<any, "limitClause"> & SparqlGrammarRule<
            "limitClause",
            number,
        >;
        limitOffsetClauses: ParserRule<
            SparqlContext,
            "limitOffsetClauses",
            Pick<
                Patch<
                    SelectQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                "offset"
                | "limit",
            >,
            undefined,
        >;
        load: ParserRule<SparqlContext, "load", LoadOperation, undefined>;
        minusGraphPattern: ParserRule<
            SparqlContext,
            "minusGraphPattern",
            Patch<MinusPattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        modify: ParserRule<
            SparqlContext,
            "modify",
            Patch<
                ModifyOperation,
                { delete: types.Quads[]; insert: types.Quads[]; where: types.Pattern[] },
            >,
            undefined,
        >;
        move: ParserRule<
            SparqlContext,
            "move",
            CopyMoveAddOperation & { type: "move" },
            undefined,
        >;
        multiplicativeExpression: ParserRule<
            SparqlContext,
            "multiplicativeExpression",
            types.Expression,
            undefined,
        >;
        namedGraphClause: ParserRule<
            SparqlContext,
            "namedGraphClause",
            types.IriTerm<string>,
            undefined,
        >;
        numericExpression: ParserRule<
            SparqlContext,
            "numericExpression",
            types.Expression,
            undefined,
        >;
        numericLiteral: ParserRule<
            SparqlContext,
            "numericLiteral",
            Literal,
            undefined,
        >;
        numericLiteralNegative: ParserRule<
            SparqlContext,
            "numericLiteralNegative",
            Literal,
            undefined,
        >;
        numericLiteralPositive: ParserRule<
            SparqlContext,
            "numericLiteralPositive",
            Literal,
            undefined,
        >;
        numericLiteralUnsigned: ParserRule<
            SparqlContext,
            "numericLiteralUnsigned",
            Literal,
            undefined,
        >;
        object: ParserRule<
            SparqlContext,
            "object",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<
                Patch<Triple, { object: types.Term; subject: types.Term }>,
                "subject" | "predicate",
            >,
        >;
        objectList: ParserRule<
            SparqlContext,
            "objectList",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject" | "predicate">,
        >;
        objectListPath: ParserRule<
            SparqlContext,
            "objectListPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject" | "predicate">,
        >;
        objectPath: ParserRule<
            SparqlContext,
            "objectPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<
                Patch<Triple, { object: types.Term; subject: types.Term }>,
                "subject" | "predicate",
            >,
        >;
        offsetClause: ParserRule<any, "offsetClause"> & SparqlGrammarRule<
            "offsetClause",
            number,
        >;
        optionalGraphPattern: ParserRule<
            SparqlContext,
            "optionalGraphPattern",
            Patch<OptionalPattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        orderClause: ParserRule<
            SparqlContext,
            "orderClause",
            Patch<Ordering, { expression: types.Expression }>[],
            undefined,
        >;
        orderCondition: ParserRule<
            SparqlContext,
            "orderCondition",
            Patch<Ordering, { expression: types.Expression }>,
            undefined,
        >;
        path: ParserRule<any, "path"> & ParserRule<
            SparqlContext,
            "path",
            PropertyPath
            | IriTerm,
            undefined,
        > & GeneratorRule<undefined, "path", PropertyPath | IriTerm, undefined>;
        pathAlternative: ParserRule<any, "pathAlternative"> & SparqlGrammarRule<
            "pathAlternative",
            PropertyPath
            | IriTerm,
        >;
        pathElt: ParserRule<any, "pathElt"> & SparqlGrammarRule<
            "pathElt",
            PropertyPath
            | IriTerm,
        >;
        pathEltOrInverse: ParserRule<any, "pathEltOrInverse"> & SparqlGrammarRule<
            "pathEltOrInverse",
            PropertyPath
            | IriTerm,
        >;
        pathMod: ParserRule<any, "pathMod"> & SparqlGrammarRule<
            "pathMod",
            "?"
            | "*"
            | "+",
        >;
        pathNegatedPropertySet: ParserRule<any, "pathNegatedPropertySet"> & SparqlGrammarRule<
            "pathNegatedPropertySet",
            [IriTermOrElt]
            | [{ items: IriTermOrElt[]; pathType: "|"; type: "path" }],
        >;
        pathOneInPropertySet: ParserRule<any, "pathOneInPropertySet"> & SparqlGrammarRule<
            "pathOneInPropertySet",
            IriTermOrElt,
        >;
        pathPrimary: ParserRule<any, "pathPrimary"> & SparqlGrammarRule<
            "pathPrimary",
            PropertyPath
            | IriTerm,
        >;
        pathSequence: ParserRule<any, "pathSequence"> & SparqlGrammarRule<
            "pathSequence",
            PropertyPath
            | IriTerm,
        >;
        prefixDecl: ParserRule<any, "prefixDecl"> & SparqlGrammarRule<
            "prefixDecl",
            [string, string],
        >;
        prefixedName: ParserRule<any, "prefixedName"> & SparqlGrammarRule<
            "prefixedName",
            IriTerm,
        >;
        primaryExpression: ParserRule<
            SparqlContext,
            "primaryExpression",
            types.Expression,
            undefined,
        >;
        prologue: ParserRule<
            SparqlContext,
            "prologue",
            Pick<
                Patch<
                    BaseQuery,
                    {
                        group?: Patch<Grouping, { expression: types.Expression }>[];
                        having?: types.Expression[];
                        order: undefined | Patch<Ordering, { expression: types.Expression }>[];
                        values?: types.ValuePatternRow[];
                        where?: types.Pattern[];
                    },
                >,
                "base"
                | "prefixes",
            >,
            undefined,
        >;
        propertyList: ParserRule<
            SparqlContext,
            "propertyList",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject">,
        >;
        propertyListNotEmpty: ParserRule<
            SparqlContext,
            "propertyListNotEmpty",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject">,
        >;
        propertyListPath: ParserRule<
            SparqlContext,
            "propertyListPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject">,
        >;
        propertyListPathNotEmpty: ParserRule<
            SparqlContext,
            "propertyListPathNotEmpty",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            Pick<Triple, "subject">,
        >;
        quadData: ParserRule<SparqlContext, "quadData", types.Quads[], undefined>;
        quadPattern: ParserRule<
            SparqlContext,
            "quadPattern",
            types.Quads[],
            undefined,
        >;
        quads: ParserRule<SparqlContext, "quads", types.Quads[], undefined>;
        quadsNotTriples: ParserRule<
            SparqlContext,
            "quadsNotTriples",
            Patch<
                GraphQuads,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >[],
            undefined,
        >;
        queryOrUpdate: ParserRule<
            SparqlContext,
            "queryOrUpdate",
            | types.Query
            | Patch<Update, { updates: types.UpdateOperation }>
            | Pick<
                Patch<Update, { updates: types.UpdateOperation }>,
                "base" | "prefixes",
            >,
            undefined,
        >;
        rdfLiteral: ParserRule<SparqlContext, "rdfLiteral", Literal, undefined>;
        reifiedTriple: ParserRule<any, "reifiedTriple"> & SparqlGrammarRule<
            "reifiedTriple",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            > & { node: BlankNode
            | Variable
            | IriTerm<string> },
            undefined,
        >;
        reifiedTripleBlock: ParserRule<any, "reifiedTripleBlock"> & SparqlGrammarRule<
            "reifiedTripleBlock",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        reifiedTripleBlockPath: ParserRule<any, "reifiedTripleBlockPath"> & SparqlGrammarRule<
            "reifiedTripleBlockPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        reifiedTripleObject: ParserRule<any, "reifiedTripleObject"> & SparqlGrammarRule<
            "reifiedTripleObject",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        reifiedTripleSubject: ParserRule<any, "reifiedTripleSubject"> & SparqlGrammarRule<
            "reifiedTripleSubject",
            Patch<
                IGraphNode,
                {
                    node: BlankNode
                    | IriTerm<string>
                    | types.Term;
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        reifier: ParserRule<any, "reifier"> & SparqlGrammarRule<
            "reifier",
            BlankNode
            | Variable
            | IriTerm<string>,
            undefined,
        >;
        relationalExpression: ParserRule<
            SparqlContext,
            "relationalExpression",
            types.Expression,
            undefined,
        >;
        selectClause: ParserRule<
            SparqlContext,
            "selectClause",
            ISelectClause,
            undefined,
        >;
        selectQuery: ParserRule<
            SparqlContext,
            "selectQuery",
            Omit<
                Patch<
                    SelectQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                HandledByBase,
            >,
            undefined,
        >;
        serviceGraphPattern: ParserRule<
            SparqlContext,
            "serviceGraphPattern",
            Patch<ServicePattern, { patterns: types.Pattern[] }>,
            undefined,
        >;
        solutionModifier: ParserRule<
            SparqlContext,
            "solutionModifier",
            Pick<
                Patch<
                    SelectQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                "offset"
                | "order"
                | "group"
                | "having"
                | "limit",
            >,
            undefined,
        >;
        sourceSelector: ParserRule<
            SparqlContext,
            "sourceSelector",
            types.IriTerm<string>,
            undefined,
        >;
        string: ParserRule<any, "string"> & ParserRule<
            SparqlContext,
            "string",
            string,
            undefined,
        > & GeneratorRule<undefined, "string", string, undefined>;
        subSelect: ParserRule<
            SparqlContext,
            "subSelect",
            Omit<
                Patch<
                    SelectQuery,
                    Patch<
                        BaseQuery,
                        {
                            group?: Patch<Grouping, { expression: ... }>[];
                            having?: types.Expression[];
                            order: undefined | Patch<Ordering, { expression: ... }>[];
                            values?: types.ValuePatternRow[];
                            where?: types.Pattern[];
                        },
                    >,
                >,
                "prefixes",
            >,
            undefined,
        >;
        triplesBlock: ParserRule<
            SparqlContext,
            "triplesBlock",
            Patch<
                BgpPattern,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        triplesNode: ParserRule<
            SparqlContext,
            "triplesNode",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        triplesNodePath: ParserRule<
            SparqlContext,
            "triplesNodePath",
            Patch<
                ITriplesNode,
                {
                    triples: Patch<Triple, { object: types.Term; subject: types.Term }>[];
                },
            >,
            undefined,
        >;
        triplesSameSubject: ParserRule<
            SparqlContext,
            "triplesSameSubject",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        triplesSameSubjectPath: ParserRule<
            SparqlContext,
            "triplesSameSubjectPath",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        triplesTemplate: ParserRule<
            SparqlContext,
            "triplesTemplate",
            Patch<Triple, { object: types.Term; subject: types.Term }>[],
            undefined,
        >;
        tripleTerm: ParserRule<any, "tripleTerm"> & ParserRule<
            SparqlContext,
            "tripleTerm",
            types.BaseQuadTerm,
            undefined,
        > & GeneratorRule<undefined, "tripleTerm", types.BaseQuadTerm, undefined>;
        tripleTermData: ParserRule<any, "tripleTermData"> & SparqlGrammarRule<
            "tripleTermData",
            types.BaseQuadTerm,
            undefined,
        >;
        tripleTermDataObject: ParserRule<any, "tripleTermDataObject"> & SparqlGrammarRule<
            "tripleTermDataObject",
            Literal
            | IriTerm<string>
            | types.BaseQuadTerm,
            undefined,
        >;
        tripleTermDataSubject: ParserRule<any, "tripleTermDataSubject"> & SparqlGrammarRule<
            "tripleTermDataSubject",
            Literal
            | IriTerm<string>,
            undefined,
        >;
        tripleTermObject: ParserRule<any, "tripleTermObject"> & SparqlGrammarRule<
            "tripleTermObject",
            BlankNode
            | Literal
            | Variable
            | IriTerm<string>
            | types.BaseQuadTerm,
            undefined,
        >;
        tripleTermSubject: ParserRule<any, "tripleTermSubject"> & SparqlGrammarRule<
            "tripleTermSubject",
            BlankNode
            | Literal
            | Variable
            | IriTerm<string>,
            undefined,
        >;
        unaryExpression: ParserRule<
            SparqlContext,
            "unaryExpression",
            types.Expression,
            undefined,
        >;
        update1: ParserRule<
            SparqlContext,
            "update1",
            types.UpdateOperation,
            undefined,
        >;
        usingClause: ParserRule<any, "usingClause"> & SparqlGrammarRule<
            "usingClause",
            { type: "default"
            | "named"; value: IriTerm },
        >;
        valueLogical: ParserRule<
            SparqlContext,
            "valueLogical",
            types.Expression,
            undefined,
        >;
        valuesClause: ParserRule<
            SparqlContext,
            "valuesClause",
            undefined
            | types.ValuePatternRow[],
            undefined,
        >;
        var: ParserRule<any, "var"> & ParserRule<
            SparqlContext,
            "var",
            Variable,
            undefined,
        > & GeneratorRule<undefined, "var", Variable, undefined>;
        varOrIri: ParserRule<any, "varOrIri"> & SparqlGrammarRule<
            "varOrIri",
            Variable
            | IriTerm,
        >;
        varOrReifierId: ParserRule<any, "varOrReifierId"> & SparqlGrammarRule<
            "varOrReifierId",
            BlankNode
            | Variable
            | IriTerm<string>,
            undefined,
        >;
        varOrTerm: ParserRule<SparqlContext, "varOrTerm", types.Term, undefined>;
        verb: ParserRule<any, "verb"> & SparqlGrammarRule<
            "verb",
            Variable
            | IriTerm,
        >;
        VerbA: ParserRule<any, "VerbA"> & SparqlGrammarRule<"VerbA", VerbA>;
        verbPath: ParserRule<any, "verbPath"> & SparqlGrammarRule<
            "verbPath",
            PropertyPath
            | IriTerm,
        >;
        verbSimple: ParserRule<any, "verbSimple"> & SparqlGrammarRule<
            "verbSimple",
            Variable,
        >;
        whereClause: ParserRule<
            SparqlContext,
            "whereClause",
            types.Pattern,
            undefined,
        >;
    },
> = ...