Variable adjustParserBuilderConst

adjustParserBuilder: ParserBuilder<
    SparqlContext,
    | "string"
    | "object"
    | "filter"
    | "add"
    | "clear"
    | "copy"
    | "move"
    | "var"
    | "path"
    | "drop"
    | "load"
    | "update"
    | "graphRef"
    | "create"
    | "modify"
    | "query"
    | "datasetClauses"
    | "bind"
    | "solutionModifier"
    | "expression"
    | "aggregate"
    | "functionCall"
    | "blankNode"
    | "queryUnit"
    | "selectQuery"
    | "subSelect"
    | "selectClause"
    | "constructQuery"
    | "describeQuery"
    | "askQuery"
    | "valuesClause"
    | "constructTemplate"
    | "constructTriples"
    | "updateUnit"
    | "update1"
    | "quadPattern"
    | "quadData"
    | "insertData"
    | "deleteData"
    | "deleteWhere"
    | "deleteClause"
    | "insertClause"
    | "graphOrDefault"
    | "graphRefAll"
    | "quads"
    | "quadsNotTriples"
    | "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"
    | "builtInCall"
    | "builtInRegex"
    | "builtInSubstr"
    | "builtInReplace"
    | "builtInExists"
    | "builtInNotexists"
    | "builtInCount"
    | "builtInSum"
    | "builtInMin"
    | "builtInMax"
    | "builtInAvg"
    | "builtInSample"
    | "builtInGroup_concat"
    | "usingClause"
    | "datasetClause"
    | "defaultGraphClause"
    | "usingClauses"
    | "namedGraphClause"
    | "sourceSelector"
    | "argList"
    | "expressionList"
    | "conditionalOrExpression"
    | "conditionalAndExpression"
    | "valueLogical"
    | "relationalExpression"
    | "numericExpression"
    | "additiveExpression"
    | "multiplicativeExpression"
    | "unaryExpression"
    | "primaryExpression"
    | "brackettedExpression"
    | "iriOrFunction"
    | "prologue"
    | "baseDecl"
    | "prefixDecl"
    | "verb"
    | "varOrTerm"
    | "varOrIri"
    | "graphTerm"
    | "rdfLiteral"
    | "numericLiteral"
    | "numericLiteralUnsigned"
    | "numericLiteralPositive"
    | "numericLiteralNegative"
    | "booleanLiteral"
    | "iri"
    | "iriFull"
    | "prefixedName"
    | "VerbA"
    | "pathEltOrInverse"
    | "pathSequence"
    | "pathAlternative"
    | "pathElt"
    | "pathMod"
    | "pathPrimary"
    | "pathNegatedPropertySet"
    | "pathOneInPropertySet"
    | "groupClause"
    | "groupCondition"
    | "havingClause"
    | "havingCondition"
    | "orderClause"
    | "orderCondition"
    | "limitOffsetClauses"
    | "limitClause"
    | "offsetClause"
    | "triplesBlock"
    | "triplesSameSubject"
    | "triplesSameSubjectPath"
    | "triplesTemplate"
    | "propertyList"
    | "propertyListPath"
    | "propertyListNotEmpty"
    | "propertyListPathNotEmpty"
    | "verbPath"
    | "verbSimple"
    | "objectList"
    | "objectListPath"
    | "objectPath"
    | "collection"
    | "collectionPath"
    | "triplesNode"
    | "triplesNodePath"
    | "blankNodePropertyList"
    | "blankNodePropertyListPath"
    | "graphNode"
    | "graphNodePath"
    | "whereClause"
    | "groupGraphPattern"
    | "groupGraphPatternSub"
    | "graphPatternNotTriples"
    | "optionalGraphPattern"
    | "graphGraphPattern"
    | "serviceGraphPattern"
    | "inlineData"
    | "dataBlock"
    | "inlineDataOneVar"
    | "inlineDataFull"
    | "dataBlockValue"
    | "minusGraphPattern"
    | "groupOrUnionGraphPattern"
    | "constraint"
    | "queryOrUpdate"
    | "builtInAdjust",
    {
        add: ParserRule<any, "add", unknown, any[]> & SparqlGrammarRule<
            "add",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        > & SparqlGeneratorRule<
            "add",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        >;
        additiveExpression: ParserRule<any, "additiveExpression", unknown, any[]> & SparqlGrammarRule<
            "additiveExpression",
            Expression,
            [],
        >;
        aggregate: ParserRule<any, "aggregate", unknown, any[]> & SparqlGrammarRule<
            "aggregate",
            ExpressionAggregate,
            [],
        > & SparqlGeneratorRule<"aggregate", ExpressionAggregate, []>;
        argList: ParserRule<any, "argList", unknown, any[]> & SparqlGrammarRule<
            "argList",
            Wrap<IArgList>,
            [],
        > & SparqlGeneratorRule<"argList", Wrap<IArgList>, []>;
        askQuery: ParserRule<any, "askQuery", unknown, any[]> & SparqlGrammarRule<
            "askQuery",
            Omit<QueryAsk, HandledByBase>,
            [],
        > & SparqlGeneratorRule<"askQuery", Omit<QueryAsk, HandledByBase>, []>;
        baseDecl: ParserRule<any, "baseDecl", unknown, any[]> & SparqlGrammarRule<
            "baseDecl",
            ContextDefinitionBase,
            [],
        > & SparqlGeneratorRule<"baseDecl", ContextDefinitionBase, []>;
        bind: ParserRule<any, "bind", unknown, any[]> & SparqlGrammarRule<
            "bind",
            PatternBind,
            [],
        > & SparqlGeneratorRule<"bind", PatternBind, []>;
        blankNode: ParserRule<any, "blankNode", unknown, any[]> & SparqlGrammarRule<
            "blankNode",
            TermBlank,
            [],
        > & SparqlGeneratorRule<"blankNode", TermBlank, []>;
        blankNodePropertyList: ParserRule<
            any,
            "blankNodePropertyList",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "blankNodePropertyList",
            TripleCollectionBlankNodeProperties,
            [],
        > & SparqlGeneratorRule<
            "blankNodePropertyList",
            TripleCollectionBlankNodeProperties,
            [],
        >;
        blankNodePropertyListPath: ParserRule<
            any,
            "blankNodePropertyListPath",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "blankNodePropertyListPath",
            TripleCollectionBlankNodeProperties,
            [],
        > & SparqlGeneratorRule<
            "blankNodePropertyListPath",
            TripleCollectionBlankNodeProperties,
            [],
        >;
        booleanLiteral: ParserRule<any, "booleanLiteral", unknown, any[]> & SparqlGrammarRule<
            "booleanLiteral",
            TermLiteralTyped,
            [],
        >;
        brackettedExpression: ParserRule<
            any,
            "brackettedExpression",
            unknown,
            any[],
        > & SparqlGrammarRule<"brackettedExpression", Expression, []>;
        builtInAbs: ParserRule<any, "builtInAbs", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInAbs",
            [Expression],
        >;
        builtInAdjust: ParserRule<
            SparqlContext,
            "builtInAdjust",
            ExpressionFunctionX<[Expression, Expression]>,
            [],
        >;
        builtInAvg: ParserRule<any, "builtInAvg", unknown, any[]> & RuleDefExpressionAggregatorX<
            "builtInAvg",
        >;
        builtInBnode: ParserRule<any, "builtInBnode", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInBnode",
            []
            | [Expression],
        >;
        builtInBound: ParserRule<any, "builtInBound", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInBound",
            [TermVariable],
        >;
        builtInCall: ParserRule<SparqlContext, "builtInCall", Expression, []>;
        builtInCeil: ParserRule<any, "builtInCeil", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInCeil",
            [Expression],
        >;
        builtInCoalesce: ParserRule<any, "builtInCoalesce", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInCoalesce",
            Expression[],
        >;
        builtInConcat: ParserRule<any, "builtInConcat", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInConcat",
            Expression[],
        >;
        builtInContains: ParserRule<any, "builtInContains", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInContains",
            [Expression, Expression],
        >;
        builtInCount: ParserRule<any, "builtInCount", unknown, any[]> & SparqlGrammarRule<
            "builtInCount",
            ExpressionAggregateDefault
            | ExpressionAggregateOnWildcard,
            [],
        >;
        builtInDatatype: ParserRule<any, "builtInDatatype", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInDatatype",
            [Expression],
        >;
        builtInDay: ParserRule<any, "builtInDay", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInDay",
            [Expression],
        >;
        builtInEncode_for_uri: ParserRule<
            any,
            "builtInEncode_for_uri",
            unknown,
            any[],
        > & RuleDefExpressionFunctionX<"builtInEncode_for_uri", [Expression]>;
        builtInExists: ParserRule<any, "builtInExists", unknown, any[]> & SparqlGrammarRule<
            "builtInExists",
            ExpressionPatternOperation,
            [],
        >;
        builtInFloor: ParserRule<any, "builtInFloor", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInFloor",
            [Expression],
        >;
        builtInGroup_concat: ParserRule<
            any,
            "builtInGroup_concat",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "builtInGroup_concat",
            ExpressionAggregateDefault
            | ExpressionAggregateSeparator,
            [],
        >;
        builtInHours: ParserRule<any, "builtInHours", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInHours",
            [Expression],
        >;
        builtInIf: ParserRule<any, "builtInIf", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIf",
            [Expression, Expression, Expression],
        >;
        builtInIri: ParserRule<any, "builtInIri", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIri",
            [Expression],
        >;
        builtInIsblank: ParserRule<any, "builtInIsblank", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIsblank",
            [Expression],
        >;
        builtInIsiri: ParserRule<any, "builtInIsiri", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIsiri",
            [Expression],
        >;
        builtInIsliteral: ParserRule<any, "builtInIsliteral", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIsliteral",
            [Expression],
        >;
        builtInIsnumeric: ParserRule<any, "builtInIsnumeric", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIsnumeric",
            [Expression],
        >;
        builtInIsuri: ParserRule<any, "builtInIsuri", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInIsuri",
            [Expression],
        >;
        builtInLang: ParserRule<any, "builtInLang", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInLang",
            [Expression],
        >;
        builtInLangmatches: ParserRule<any, "builtInLangmatches", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInLangmatches",
            [Expression, Expression],
        >;
        builtInLcase: ParserRule<any, "builtInLcase", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInLcase",
            [Expression],
        >;
        builtInMax: ParserRule<any, "builtInMax", unknown, any[]> & RuleDefExpressionAggregatorX<
            "builtInMax",
        >;
        builtInMd5: ParserRule<any, "builtInMd5", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInMd5",
            [Expression],
        >;
        builtInMin: ParserRule<any, "builtInMin", unknown, any[]> & RuleDefExpressionAggregatorX<
            "builtInMin",
        >;
        builtInMinutes: ParserRule<any, "builtInMinutes", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInMinutes",
            [Expression],
        >;
        builtInMonth: ParserRule<any, "builtInMonth", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInMonth",
            [Expression],
        >;
        builtInNotexists: ParserRule<any, "builtInNotexists", unknown, any[]> & SparqlGrammarRule<
            "builtInNotexists",
            ExpressionPatternOperation,
            [],
        >;
        builtInNow: ParserRule<any, "builtInNow", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInNow",
            [],
        >;
        builtInRand: ParserRule<any, "builtInRand", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInRand",
            [],
        >;
        builtInRegex: ParserRule<any, "builtInRegex", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInRegex",
            [Expression, Expression]
            | [Expression, Expression, Expression],
        >;
        builtInReplace: ParserRule<any, "builtInReplace", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInReplace",
            | [Expression, Expression, Expression]
            | [Expression, Expression, Expression, Expression],
        >;
        builtInRound: ParserRule<any, "builtInRound", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInRound",
            [Expression],
        >;
        builtInSameterm: ParserRule<any, "builtInSameterm", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSameterm",
            [Expression, Expression],
        >;
        builtInSample: ParserRule<any, "builtInSample", unknown, any[]> & RuleDefExpressionAggregatorX<
            "builtInSample",
        >;
        builtInSeconds: ParserRule<any, "builtInSeconds", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSeconds",
            [Expression],
        >;
        builtInSha1: ParserRule<any, "builtInSha1", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSha1",
            [Expression],
        >;
        builtInSha256: ParserRule<any, "builtInSha256", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSha256",
            [Expression],
        >;
        builtInSha384: ParserRule<any, "builtInSha384", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSha384",
            [Expression],
        >;
        builtInSha512: ParserRule<any, "builtInSha512", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSha512",
            [Expression],
        >;
        builtInStr: ParserRule<any, "builtInStr", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStr",
            [Expression],
        >;
        builtInStrafter: ParserRule<any, "builtInStrafter", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrafter",
            [Expression, Expression],
        >;
        builtInStrbefore: ParserRule<any, "builtInStrbefore", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrbefore",
            [Expression, Expression],
        >;
        builtInStrdt: ParserRule<any, "builtInStrdt", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrdt",
            [Expression, Expression],
        >;
        builtInStrends: ParserRule<any, "builtInStrends", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrends",
            [Expression, Expression],
        >;
        builtInStrlang: ParserRule<any, "builtInStrlang", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrlang",
            [Expression, Expression],
        >;
        builtInStrlen: ParserRule<any, "builtInStrlen", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrlen",
            [Expression],
        >;
        builtInStrstarts: ParserRule<any, "builtInStrstarts", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStrstarts",
            [Expression, Expression],
        >;
        builtInStruuid: ParserRule<any, "builtInStruuid", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInStruuid",
            [],
        >;
        builtInSubstr: ParserRule<any, "builtInSubstr", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInSubstr",
            [Expression, Expression]
            | [Expression, Expression, Expression],
        >;
        builtInSum: ParserRule<any, "builtInSum", unknown, any[]> & RuleDefExpressionAggregatorX<
            "builtInSum",
        >;
        builtInTimezone: ParserRule<any, "builtInTimezone", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInTimezone",
            [Expression],
        >;
        builtInTz: ParserRule<any, "builtInTz", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInTz",
            [Expression],
        >;
        builtInUcase: ParserRule<any, "builtInUcase", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInUcase",
            [Expression],
        >;
        builtInUri: ParserRule<any, "builtInUri", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInUri",
            [Expression],
        >;
        builtInUuid: ParserRule<any, "builtInUuid", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInUuid",
            [],
        >;
        builtInYear: ParserRule<any, "builtInYear", unknown, any[]> & RuleDefExpressionFunctionX<
            "builtInYear",
            [Expression],
        >;
        clear: ParserRule<any, "clear", unknown, any[]> & SparqlGrammarRule<
            "clear",
            UpdateOperationClear
            | UpdateOperationDrop,
            [],
        > & SparqlGeneratorRule<
            "clear",
            UpdateOperationClear
            | UpdateOperationDrop,
            [],
        >;
        collection: ParserRule<any, "collection", unknown, any[]> & SparqlGrammarRule<
            "collection",
            TripleCollectionList,
            [],
        > & SparqlGeneratorRule<"collection", TripleCollectionList, []>;
        collectionPath: ParserRule<any, "collectionPath", unknown, any[]> & SparqlGrammarRule<
            "collectionPath",
            TripleCollectionList,
            [],
        > & SparqlGeneratorRule<"collectionPath", TripleCollectionList, []>;
        conditionalAndExpression: ParserRule<
            any,
            "conditionalAndExpression",
            unknown,
            any[],
        > & SparqlGrammarRule<"conditionalAndExpression", Expression, []>;
        conditionalOrExpression: ParserRule<
            any,
            "conditionalOrExpression",
            unknown,
            any[],
        > & SparqlGrammarRule<"conditionalOrExpression", Expression, []>;
        constraint: ParserRule<any, "constraint", unknown, any[]> & SparqlGrammarRule<
            "constraint",
            Expression,
            [],
        >;
        constructQuery: ParserRule<any, "constructQuery", unknown, any[]> & SparqlGrammarRule<
            "constructQuery",
            Omit<QueryConstruct, HandledByBase>,
            [],
        > & SparqlGeneratorRule<
            "constructQuery",
            Omit<QueryConstruct, HandledByBase>,
            [],
        >;
        constructTemplate: ParserRule<
            SparqlContext,
            "constructTemplate",
            Wrap<PatternBgp>,
            [],
        >;
        constructTriples: ParserRule<
            SparqlContext,
            "constructTriples",
            PatternBgp,
            [],
        >;
        copy: ParserRule<any, "copy", unknown, any[]> & SparqlGrammarRule<
            "copy",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        > & SparqlGeneratorRule<
            "copy",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        >;
        create: ParserRule<any, "create", unknown, any[]> & SparqlGrammarRule<
            "create",
            UpdateOperationCreate,
            [],
        > & SparqlGeneratorRule<"create", UpdateOperationCreate, []>;
        dataBlock: ParserRule<any, "dataBlock", unknown, any[]> & SparqlGrammarRule<
            "dataBlock",
            Wrap<ValuePatternRow[]>,
            [],
        >;
        dataBlockValue: ParserRule<any, "dataBlockValue", unknown, any[]> & SparqlGrammarRule<
            "dataBlockValue",
            undefined
            | TermIri
            | TermLiteral,
            [],
        >;
        datasetClause: ParserRule<
            SparqlContext,
            "datasetClause",
            Wrap<{ clauseType: "default" | "named"; value: TermIri }>,
            [],
        >;
        datasetClauses: ParserRule<
            SparqlContext,
            "datasetClauses",
            DatasetClauses,
            [],
        >;
        defaultGraphClause: ParserRule<
            SparqlContext,
            "defaultGraphClause",
            TermIri,
            [],
        >;
        deleteClause: ParserRule<any, "deleteClause", unknown, any[]> & SparqlGrammarRule<
            "deleteClause",
            Wrap<Quads[]>,
            [],
        >;
        deleteData: ParserRule<any, "deleteData", unknown, any[]> & SparqlGrammarRule<
            "deleteData",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        > & SparqlGeneratorRule<
            "deleteData",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        >;
        deleteWhere: ParserRule<any, "deleteWhere", unknown, any[]> & SparqlGrammarRule<
            "deleteWhere",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        > & SparqlGeneratorRule<
            "deleteWhere",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        >;
        describeQuery: ParserRule<any, "describeQuery", unknown, any[]> & SparqlGrammarRule<
            "describeQuery",
            Omit<QueryDescribe, HandledByBase>,
            [],
        > & SparqlGeneratorRule<
            "describeQuery",
            Omit<QueryDescribe, HandledByBase>,
            [],
        >;
        drop: ParserRule<any, "drop", unknown, any[]> & SparqlGrammarRule<
            "drop",
            UpdateOperationClear
            | UpdateOperationDrop,
            [],
        > & SparqlGeneratorRule<
            "drop",
            UpdateOperationClear
            | UpdateOperationDrop,
            [],
        >;
        expression: ParserRule<any, "expression", unknown, any[]> & SparqlGrammarRule<
            "expression",
            Expression,
            [],
        > & SparqlGeneratorRule<"expression", Expression, []>;
        expressionList: ParserRule<any, "expressionList", unknown, any[]> & SparqlGrammarRule<
            "expressionList",
            Wrap<Expression[]>,
            [],
        >;
        filter: ParserRule<any, "filter", unknown, any[]> & SparqlGrammarRule<
            "filter",
            PatternFilter,
            [],
        > & SparqlGeneratorRule<"filter", PatternFilter, []>;
        functionCall: ParserRule<any, "functionCall", unknown, any[]> & SparqlGrammarRule<
            "functionCall",
            ExpressionFunctionCall,
            [],
        >;
        graphGraphPattern: ParserRule<any, "graphGraphPattern", unknown, any[]> & SparqlGrammarRule<
            "graphGraphPattern",
            PatternGraph,
            [],
        > & SparqlGeneratorRule<"graphGraphPattern", PatternGraph, []>;
        graphNode: ParserRule<any, "graphNode", unknown, any[]> & SparqlGrammarRule<
            "graphNode",
            TripleCollection
            | Term,
            [],
        > & SparqlGeneratorRule<"graphNode", TripleCollection | Term, []>;
        graphNodePath: ParserRule<any, "graphNodePath", unknown, any[]> & SparqlGrammarRule<
            "graphNodePath",
            TripleCollection
            | Term,
            [],
        > & SparqlGeneratorRule<"graphNodePath", TripleCollection | Term, []>;
        graphOrDefault: ParserRule<any, "graphOrDefault", unknown, any[]> & SparqlGrammarRule<
            "graphOrDefault",
            GraphRefDefault
            | GraphRefSpecific,
            [],
        >;
        graphPatternNotTriples: ParserRule<
            any,
            "graphPatternNotTriples",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "graphPatternNotTriples",
            | PatternGroup
            | PatternUnion
            | PatternOptional
            | PatternMinus
            | PatternGraph
            | PatternService
            | PatternFilter
            | PatternBind
            | PatternValues,
            [],
        > & SparqlGeneratorRule<
            "graphPatternNotTriples",
            | PatternGroup
            | PatternUnion
            | PatternOptional
            | PatternMinus
            | PatternGraph
            | PatternService
            | PatternFilter
            | PatternBind
            | PatternValues,
            [],
        >;
        graphRef: ParserRule<any, "graphRef", unknown, any[]> & SparqlGrammarRule<
            "graphRef",
            GraphRefSpecific,
            [],
        > & SparqlGeneratorRule<"graphRef", GraphRefSpecific, []>;
        graphRefAll: ParserRule<any, "graphRefAll", unknown, any[]> & SparqlGrammarRule<
            "graphRefAll",
            GraphRef,
            [],
        > & SparqlGeneratorRule<"graphRefAll", GraphRef, []>;
        graphTerm: ParserRule<any, "graphTerm", unknown, any[]> & SparqlGrammarRule<
            "graphTerm",
            GraphTerm,
            [],
        > & SparqlGeneratorRule<"graphTerm", GraphTerm, []>;
        groupClause: ParserRule<any, "groupClause", unknown, any[]> & SparqlGrammarRule<
            "groupClause",
            SolutionModifierGroup,
            [],
        > & SparqlGeneratorRule<"groupClause", SolutionModifierGroup, []>;
        groupCondition: ParserRule<any, "groupCondition", unknown, any[]> & SparqlGrammarRule<
            "groupCondition",
            Expression
            | SolutionModifierGroupBind,
            [],
        >;
        groupGraphPattern: ParserRule<any, "groupGraphPattern", unknown, any[]> & SparqlGrammarRule<
            "groupGraphPattern",
            PatternGroup,
            [],
        > & SparqlGeneratorRule<"groupGraphPattern", PatternGroup, []>;
        groupGraphPatternSub: ParserRule<
            any,
            "groupGraphPatternSub",
            unknown,
            any[],
        > & SparqlGrammarRule<"groupGraphPatternSub", Pattern[], []>;
        groupOrUnionGraphPattern: ParserRule<
            any,
            "groupOrUnionGraphPattern",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "groupOrUnionGraphPattern",
            PatternGroup
            | PatternUnion,
            [],
        > & SparqlGeneratorRule<
            "groupOrUnionGraphPattern",
            PatternGroup
            | PatternUnion,
            [],
        >;
        havingClause: ParserRule<any, "havingClause", unknown, any[]> & SparqlGrammarRule<
            "havingClause",
            SolutionModifierHaving,
            [],
        > & SparqlGeneratorRule<"havingClause", SolutionModifierHaving, []>;
        havingCondition: ParserRule<any, "havingCondition", unknown, any[]> & SparqlGrammarRule<
            "havingCondition",
            Expression,
            [],
        >;
        inlineData: ParserRule<any, "inlineData", unknown, any[]> & SparqlGrammarRule<
            "inlineData",
            PatternValues,
            [],
        > & SparqlGeneratorRule<"inlineData", PatternValues, []>;
        inlineDataFull: ParserRule<any, "inlineDataFull", unknown, any[]> & SparqlGrammarRule<
            "inlineDataFull",
            Wrap<ValuePatternRow[]>,
            [],
        >;
        inlineDataOneVar: ParserRule<any, "inlineDataOneVar", unknown, any[]> & SparqlGrammarRule<
            "inlineDataOneVar",
            Wrap<ValuePatternRow[]>,
            [],
        >;
        insertClause: ParserRule<any, "insertClause", unknown, any[]> & SparqlGrammarRule<
            "insertClause",
            Wrap<Quads[]>,
            [],
        >;
        insertData: ParserRule<any, "insertData", unknown, any[]> & SparqlGrammarRule<
            "insertData",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        > & SparqlGeneratorRule<
            "insertData",
            | UpdateOperationInsertData
            | UpdateOperationDeleteData
            | UpdateOperationDeleteWhere,
            [],
        >;
        iri: ParserRule<any, "iri", unknown, any[]> & SparqlGrammarRule<
            "iri",
            TermIri,
            [],
        > & SparqlGeneratorRule<"iri", TermIri, []>;
        iriFull: ParserRule<any, "iriFull", unknown, any[]> & SparqlGrammarRule<
            "iriFull",
            TermIriFull,
            [],
        > & SparqlGeneratorRule<"iriFull", TermIriFull, []>;
        iriOrFunction: ParserRule<any, "iriOrFunction", unknown, any[]> & SparqlGrammarRule<
            "iriOrFunction",
            ExpressionFunctionCall
            | TermIri,
            [],
        > & SparqlGeneratorRule<
            "iriOrFunction",
            ExpressionFunctionCall
            | TermIri,
            [],
        >;
        limitClause: ParserRule<any, "limitClause", unknown, any[]> & SparqlGrammarRule<
            "limitClause",
            Wrap<number>,
            [],
        >;
        limitOffsetClauses: ParserRule<any, "limitOffsetClauses", unknown, any[]> & SparqlGrammarRule<
            "limitOffsetClauses",
            SolutionModifierLimitOffset,
            [],
        > & SparqlGeneratorRule<
            "limitOffsetClauses",
            SolutionModifierLimitOffset,
            [],
        >;
        load: ParserRule<any, "load", unknown, any[]> & SparqlGrammarRule<
            "load",
            UpdateOperationLoad,
            [],
        > & SparqlGeneratorRule<"load", UpdateOperationLoad, []>;
        minusGraphPattern: ParserRule<any, "minusGraphPattern", unknown, any[]> & SparqlGrammarRule<
            "minusGraphPattern",
            PatternMinus,
            [],
        > & SparqlGeneratorRule<"minusGraphPattern", PatternMinus, []>;
        modify: ParserRule<any, "modify", unknown, any[]> & SparqlGrammarRule<
            "modify",
            UpdateOperationModify,
            [],
        > & SparqlGeneratorRule<"modify", UpdateOperationModify, []>;
        move: ParserRule<any, "move", unknown, any[]> & SparqlGrammarRule<
            "move",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        > & SparqlGeneratorRule<
            "move",
            UpdateOperationAdd
            | UpdateOperationMove
            | UpdateOperationCopy,
            [],
        >;
        multiplicativeExpression: ParserRule<
            any,
            "multiplicativeExpression",
            unknown,
            any[],
        > & SparqlGrammarRule<"multiplicativeExpression", Expression, []>;
        namedGraphClause: ParserRule<
            SparqlContext,
            "namedGraphClause",
            Wrap<TermIri>,
            [],
        >;
        numericExpression: ParserRule<any, "numericExpression", unknown, any[]> & SparqlGrammarRule<
            "numericExpression",
            Expression,
            [],
        >;
        numericLiteral: ParserRule<any, "numericLiteral", unknown, any[]> & SparqlGrammarRule<
            "numericLiteral",
            TermLiteralTyped,
            [],
        >;
        numericLiteralNegative: ParserRule<
            any,
            "numericLiteralNegative",
            unknown,
            any[],
        > & SparqlGrammarRule<"numericLiteralNegative", TermLiteralTyped, []>;
        numericLiteralPositive: ParserRule<
            any,
            "numericLiteralPositive",
            unknown,
            any[],
        > & SparqlGrammarRule<"numericLiteralPositive", TermLiteralTyped, []>;
        numericLiteralUnsigned: ParserRule<
            any,
            "numericLiteralUnsigned",
            unknown,
            any[],
        > & SparqlGrammarRule<"numericLiteralUnsigned", TermLiteralTyped, []>;
        object: ParserRule<any, "object", unknown, any[]> & SparqlGrammarRule<
            "object",
            TripleNesting,
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectList: ParserRule<any, "objectList", unknown, any[]> & SparqlGrammarRule<
            "objectList",
            TripleNesting[],
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectListPath: ParserRule<any, "objectListPath", unknown, any[]> & SparqlGrammarRule<
            "objectListPath",
            TripleNesting[],
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectPath: ParserRule<any, "objectPath", unknown, any[]> & SparqlGrammarRule<
            "objectPath",
            TripleNesting,
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        offsetClause: ParserRule<any, "offsetClause", unknown, any[]> & SparqlGrammarRule<
            "offsetClause",
            Wrap<number>,
            [],
        >;
        optionalGraphPattern: ParserRule<
            any,
            "optionalGraphPattern",
            unknown,
            any[],
        > & SparqlGrammarRule<"optionalGraphPattern", PatternOptional, []> & SparqlGeneratorRule<
            "optionalGraphPattern",
            PatternOptional,
            [],
        >;
        orderClause: ParserRule<any, "orderClause", unknown, any[]> & SparqlGrammarRule<
            "orderClause",
            SolutionModifierOrder,
            [],
        > & SparqlGeneratorRule<"orderClause", SolutionModifierOrder, []>;
        orderCondition: ParserRule<any, "orderCondition", unknown, any[]> & SparqlGrammarRule<
            "orderCondition",
            Ordering,
            [],
        >;
        path: ParserRule<any, "path", unknown, any[]> & SparqlGrammarRule<
            "path",
            Path,
            [],
        >;
        pathAlternative: ParserRule<any, "pathAlternative", unknown, any[]> & SparqlGrammarRule<
            "pathAlternative",
            | TermIriFull
            | TermIriPrefixed
            | PropertyPathChain
            | PathModified
            | PathNegated,
            [],
        >;
        pathElt: ParserRule<any, "pathElt", unknown, any[]> & SparqlGrammarRule<
            "pathElt",
            Path,
            [],
        >;
        pathEltOrInverse: ParserRule<any, "pathEltOrInverse", unknown, any[]> & SparqlGrammarRule<
            "pathEltOrInverse",
            Path,
            [],
        >;
        pathMod: ParserRule<any, "pathMod", unknown, any[]> & SparqlGrammarRule<
            "pathMod",
            IToken & { image: "?"
            | "*"
            | "+" },
            [],
        >;
        pathNegatedPropertySet: ParserRule<
            any,
            "pathNegatedPropertySet",
            unknown,
            any[],
        > & SparqlGrammarRule<"pathNegatedPropertySet", PathNegated, []>;
        pathOneInPropertySet: ParserRule<
            any,
            "pathOneInPropertySet",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "pathOneInPropertySet",
            TermIri
            | PathNegatedElt,
            [],
        >;
        pathPrimary: ParserRule<any, "pathPrimary", unknown, any[]> & SparqlGrammarRule<
            "pathPrimary",
            Path,
            [],
        >;
        pathSequence: ParserRule<any, "pathSequence", unknown, any[]> & SparqlGrammarRule<
            "pathSequence",
            | TermIriFull
            | TermIriPrefixed
            | PropertyPathChain
            | PathModified
            | PathNegated,
            [],
        >;
        prefixDecl: ParserRule<any, "prefixDecl", unknown, any[]> & SparqlGrammarRule<
            "prefixDecl",
            ContextDefinitionPrefix,
            [],
        > & SparqlGeneratorRule<"prefixDecl", ContextDefinitionPrefix, []>;
        prefixedName: ParserRule<any, "prefixedName", unknown, any[]> & SparqlGrammarRule<
            "prefixedName",
            TermIriPrefixed,
            [],
        > & SparqlGeneratorRule<"prefixedName", TermIriPrefixed, []>;
        primaryExpression: ParserRule<any, "primaryExpression", unknown, any[]> & SparqlGrammarRule<
            "primaryExpression",
            Expression,
            [],
        >;
        prologue: ParserRule<any, "prologue", unknown, any[]> & SparqlGrammarRule<
            "prologue",
            ContextDefinition[],
            [],
        > & SparqlGeneratorRule<"prologue", ContextDefinition[], []>;
        propertyList: ParserRule<any, "propertyList", unknown, any[]> & SparqlGrammarRule<
            "propertyList",
            TripleNesting[],
            [GraphNode],
        >;
        propertyListNotEmpty: ParserRule<
            any,
            "propertyListNotEmpty",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "propertyListNotEmpty",
            TripleNesting[],
            [GraphNode],
        >;
        propertyListPath: ParserRule<any, "propertyListPath", unknown, any[]> & SparqlGrammarRule<
            "propertyListPath",
            TripleNesting[],
            [GraphNode],
        >;
        propertyListPathNotEmpty: ParserRule<
            any,
            "propertyListPathNotEmpty",
            unknown,
            any[],
        > & SparqlGrammarRule<
            "propertyListPathNotEmpty",
            TripleNesting[],
            [GraphNode],
        >;
        quadData: ParserRule<any, "quadData", unknown, any[]> & SparqlGrammarRule<
            "quadData",
            Wrap<Quads[]>,
            [],
        >;
        quadPattern: ParserRule<SparqlContext, "quadPattern", Wrap<Quads[]>, []>;
        quads: ParserRule<any, "quads", unknown, any[]> & SparqlGrammarRule<
            "quads",
            Wrap<Quads[]>,
            [],
        > & SparqlGeneratorRule<"quads", Wrap<Quads[]>, []>;
        quadsNotTriples: ParserRule<
            SparqlContext,
            "quadsNotTriples",
            GraphQuads,
            [],
        >;
        query: ParserRule<any, "query", unknown, any[]> & SparqlGrammarRule<
            "query",
            Query,
            [],
        > & SparqlGeneratorRule<"query", Query, []>;
        queryOrUpdate: ParserRule<SparqlContext, "queryOrUpdate", SparqlQuery, []>;
        queryUnit: ParserRule<any, "queryUnit", unknown, any[]> & SparqlGrammarRule<
            "queryUnit",
            Query,
            [],
        >;
        rdfLiteral: ParserRule<any, "rdfLiteral", unknown, any[]> & SparqlGrammarRule<
            "rdfLiteral",
            TermLiteral,
            [],
        > & SparqlGeneratorRule<"rdfLiteral", TermLiteral, []>;
        relationalExpression: ParserRule<
            any,
            "relationalExpression",
            unknown,
            any[],
        > & SparqlGrammarRule<"relationalExpression", Expression, []>;
        selectClause: ParserRule<any, "selectClause", unknown, any[]> & SparqlGrammarRule<
            "selectClause",
            Wrap<Pick<QuerySelect, "variables" | "distinct" | "reduced">>,
            [],
        > & SparqlGeneratorRule<
            "selectClause",
            Wrap<Pick<QuerySelect, "variables" | "distinct" | "reduced">>,
            [],
        >;
        selectQuery: ParserRule<any, "selectQuery", unknown, any[]> & SparqlGrammarRule<
            "selectQuery",
            Omit<QuerySelect, HandledByBase>,
            [],
        > & SparqlGeneratorRule<
            "selectQuery",
            Omit<QuerySelect, HandledByBase>,
            [],
        >;
        serviceGraphPattern: ParserRule<
            any,
            "serviceGraphPattern",
            unknown,
            any[],
        > & SparqlGrammarRule<"serviceGraphPattern", PatternService, []> & SparqlGeneratorRule<
            "serviceGraphPattern",
            PatternService,
            [],
        >;
        solutionModifier: ParserRule<any, "solutionModifier", unknown, any[]> & SparqlGrammarRule<
            "solutionModifier",
            SolutionModifiers,
            [],
        > & SparqlGeneratorRule<"solutionModifier", SolutionModifiers, []>;
        sourceSelector: ParserRule<SparqlContext, "sourceSelector", TermIri, []>;
        string: ParserRule<any, "string", unknown, any[]> & SparqlGrammarRule<
            "string",
            TermLiteralStr,
            [],
        >;
        subSelect: ParserRule<any, "subSelect", unknown, any[]> & SparqlGrammarRule<
            "subSelect",
            QuerySelect,
            [],
        >;
        triplesBlock: ParserRule<any, "triplesBlock", unknown, any[]> & SparqlGrammarRule<
            "triplesBlock",
            PatternBgp,
            [],
        > & SparqlGeneratorRule<"triplesBlock", PatternBgp, []>;
        triplesNode: ParserRule<any, "triplesNode", unknown, any[]> & SparqlGrammarRule<
            "triplesNode",
            TripleCollection,
            [],
        > & SparqlGeneratorRule<"triplesNode", TripleCollection, []>;
        triplesNodePath: ParserRule<any, "triplesNodePath", unknown, any[]> & SparqlGrammarRule<
            "triplesNodePath",
            TripleCollection,
            [],
        > & SparqlGeneratorRule<"triplesNodePath", TripleCollection, []>;
        triplesSameSubject: ParserRule<any, "triplesSameSubject", unknown, any[]> & SparqlGrammarRule<
            "triplesSameSubject",
            BasicGraphPattern,
            [],
        >;
        triplesSameSubjectPath: ParserRule<
            any,
            "triplesSameSubjectPath",
            unknown,
            any[],
        > & SparqlGrammarRule<"triplesSameSubjectPath", BasicGraphPattern, []>;
        triplesTemplate: ParserRule<any, "triplesTemplate", unknown, any[]> & SparqlGrammarRule<
            "triplesTemplate",
            PatternBgp,
            [],
        >;
        unaryExpression: ParserRule<any, "unaryExpression", unknown, any[]> & SparqlGrammarRule<
            "unaryExpression",
            Expression,
            [],
        >;
        update: ParserRule<any, "update", unknown, any[]> & SparqlGrammarRule<
            "update",
            Update,
            [],
        > & SparqlGeneratorRule<"update", Update, []>;
        update1: ParserRule<SparqlContext, "update1", UpdateOperation, []>;
        updateUnit: ParserRule<any, "updateUnit", unknown, any[]> & SparqlGrammarRule<
            "updateUnit",
            Update,
            [],
        >;
        usingClause: ParserRule<any, "usingClause", unknown, any[]> & SparqlGrammarRule<
            "usingClause",
            Wrap<{ clauseType: "default" | "named"; value: TermIri }>,
            [],
        >;
        usingClauses: ParserRule<any, "usingClauses", unknown, any[]> & SparqlGrammarRule<
            "usingClauses",
            DatasetClauses,
            [],
        > & SparqlGeneratorRule<"usingClauses", DatasetClauses, []>;
        valueLogical: ParserRule<any, "valueLogical", unknown, any[]> & SparqlGrammarRule<
            "valueLogical",
            Expression,
            [],
        >;
        valuesClause: ParserRule<any, "valuesClause", unknown, any[]> & SparqlGrammarRule<
            "valuesClause",
            undefined
            | PatternValues,
            [],
        >;
        var: ParserRule<any, "var", unknown, any[]> & SparqlGrammarRule<
            "var",
            TermVariable,
            [],
        > & SparqlGeneratorRule<"var", TermVariable, []>;
        varOrIri: ParserRule<any, "varOrIri", unknown, any[]> & SparqlGrammarRule<
            "varOrIri",
            TermIri
            | TermVariable,
            [],
        >;
        varOrTerm: ParserRule<any, "varOrTerm", unknown, any[]> & SparqlGrammarRule<
            "varOrTerm",
            Term,
            [],
        > & SparqlGeneratorRule<"varOrTerm", Term, []>;
        verb: ParserRule<any, "verb", unknown, any[]> & SparqlGrammarRule<
            "verb",
            TermIri
            | TermVariable,
            [],
        >;
        VerbA: ParserRule<any, "VerbA", unknown, any[]> & SparqlGrammarRule<
            "VerbA",
            TermIriFull,
            [],
        >;
        verbPath: ParserRule<any, "verbPath", unknown, any[]> & SparqlGrammarRule<
            "verbPath",
            Path,
            [],
        >;
        verbSimple: ParserRule<any, "verbSimple", unknown, any[]> & SparqlGrammarRule<
            "verbSimple",
            TermVariable,
            [],
        >;
        whereClause: ParserRule<any, "whereClause", unknown, any[]> & SparqlGrammarRule<
            "whereClause",
            Wrap<PatternGroup>,
            [],
        > & SparqlGeneratorRule<"whereClause", Wrap<PatternGroup>, []>;
    },
> = ...