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