@traqula/parser-sparql-1-1 0.0.1-alpha.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (34) hide show
  1. package/LICENSE.txt +22 -0
  2. package/README.md +87 -0
  3. package/lib/Parser.d.ts +214 -0
  4. package/lib/Parser.js +72 -0
  5. package/lib/Parser.js.map +1 -0
  6. package/lib/expressionParser.d.ts +89 -0
  7. package/lib/expressionParser.js +51 -0
  8. package/lib/expressionParser.js.map +1 -0
  9. package/lib/index.cjs +15183 -0
  10. package/lib/index.d.ts +9 -0
  11. package/lib/index.js +10 -0
  12. package/lib/index.js.map +1 -0
  13. package/lib/objectListParser.d.ts +27 -0
  14. package/lib/objectListParser.js +31 -0
  15. package/lib/objectListParser.js.map +1 -0
  16. package/lib/queryUnitParser.d.ts +181 -0
  17. package/lib/queryUnitParser.js +29 -0
  18. package/lib/queryUnitParser.js.map +1 -0
  19. package/lib/subSelectParser.d.ts +159 -0
  20. package/lib/subSelectParser.js +20 -0
  21. package/lib/subSelectParser.js.map +1 -0
  22. package/lib/triplesBlockParser.d.ts +50 -0
  23. package/lib/triplesBlockParser.js +21 -0
  24. package/lib/triplesBlockParser.js.map +1 -0
  25. package/lib/triplesTemplateParserBuilder.d.ts +30 -0
  26. package/lib/triplesTemplateParserBuilder.js +33 -0
  27. package/lib/triplesTemplateParserBuilder.js.map +1 -0
  28. package/lib/updateNoModifyParser.d.ts +58 -0
  29. package/lib/updateNoModifyParser.js +55 -0
  30. package/lib/updateNoModifyParser.js.map +1 -0
  31. package/lib/updateUnitParser.d.ts +196 -0
  32. package/lib/updateUnitParser.js +12 -0
  33. package/lib/updateUnitParser.js.map +1 -0
  34. package/package.json +61 -0
package/LICENSE.txt ADDED
@@ -0,0 +1,22 @@
1
+ The MIT License (MIT)
2
+
3
+ Copyright © 2024–now Jitse De Smet
4
+ Comunica Association and Ghent University – imec, Belgium
5
+
6
+ Permission is hereby granted, free of charge, to any person obtaining a copy
7
+ of this software and associated documentation files (the "Software"), to deal
8
+ in the Software without restriction, including without limitation the rights
9
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10
+ copies of the Software, and to permit persons to whom the Software is
11
+ furnished to do so, subject to the following conditions:
12
+
13
+ The above copyright notice and this permission notice shall be included in
14
+ all copies or substantial portions of the Software.
15
+
16
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22
+ THE SOFTWARE.
package/README.md ADDED
@@ -0,0 +1,87 @@
1
+ <p align="center">
2
+ <img alt="Traqula logo" width="70%" style="border-radius: 20px" src="/assets/white-on-red/logo-white-on-red-lettered-social.png">
3
+ </p>
4
+
5
+ <p align="center">
6
+ <strong>A query language transpiler framework for JavaScript</strong>
7
+ </p>
8
+
9
+ **WARNING:** V2 will come shortly and will have lots of breaking changes.
10
+
11
+ # Traqula parser engine for SPARQL 1.1
12
+
13
+ Traqula Sparql 1.1 is a [SPARQL 1.1](https://www.w3.org/TR/sparql11-query/#grammar) query parser for TypeScript.
14
+
15
+ ## Installation
16
+
17
+ ```bash
18
+ npm install @traqula/parser-sparql-1-1
19
+ ```
20
+
21
+ or
22
+
23
+ ```bash
24
+ yarn add @traqula/parser-sparql-1-1
25
+ ```
26
+
27
+ ## Import
28
+
29
+ Either through ESM import:
30
+
31
+ ```javascript
32
+ import {Parser} from 'engines/parser-sparql-1-1';
33
+ ```
34
+
35
+ _or_ CJS require:
36
+
37
+ ```javascript
38
+ const Parser = require('engines/parser-sparql-1-1').Parser;
39
+ ```
40
+
41
+ ## Usage
42
+
43
+ This package contains a `Parser` that is able to parse SPARQL 1.1 queries:
44
+
45
+ ```typescript
46
+ const parser = new Parser();
47
+ const abstractSyntaxTree = parser.parse('SELECT * { ?s ?p ?o }');
48
+ ```
49
+
50
+ The package also contains multiple parserBuilders.
51
+ These builders can be used either to consume to a parser,
52
+ or to usage as a starting point for your own grammar.
53
+
54
+ ### Consuming parserBuilder to parser
55
+
56
+ At the core of Traqula, parser are constructed of multiple parser rules that have been consumed by the builder.
57
+ This consumption returns a parser that can parse strings starting from any grammar rule.
58
+
59
+ The `sparql11ParserBuilder` for example contains both the rules `queryOrUpdate` and `path` (among many others).
60
+ The consumption of `sparql11ParserBuilder` will thus return an object that has function `queryOrUpdate` and `path`.
61
+ Calling those function with a string will cause that string to be parsed using the appropriate rule as a starting rule.
62
+
63
+ ```typescript
64
+ const parser: {
65
+ queryOrUpdate: (input: string) => SparqlQuery;
66
+ path: (input: string) => PropertyPath | IriTerm;
67
+ } = sparql11ParserBuilder.consumeToParser({
68
+ tokenVocabulary: l.sparql11Tokens.build(),
69
+ }, {
70
+ parseMode: new Set([ gram.canParseVars, gram.canCreateBlankNodes ]),
71
+ dataFactory: new DataFactory(),
72
+ });
73
+ ```
74
+
75
+ ### Constructing a new grammar from an existing one
76
+
77
+ The builders can also be used to construct new parsers.
78
+ As an example the `triplesBlockParserBuilder` is created by merging the `objectListBuilder` with some new rules.
79
+
80
+ ## Configuration
81
+
82
+ Optionally, the following parameters can be set in the `Parser` constructor:
83
+
84
+ * `dataFactory`: A custom [RDFJS DataFactory](http://rdf.js.org/#datafactory-interface) to construct terms and triples. _(Default: `require('@rdfjs/data-model')`)_
85
+ * `baseIRI`: An initial default base IRI. _(Default: none)_
86
+ * `prefixes`: An initial map of prefixes
87
+ * `skipValidation`: Can be used to disable the validation that used variables in a select clause are in scope.
package/lib/Parser.d.ts ADDED
@@ -0,0 +1,214 @@
1
+ import { ParserBuilder } from '@traqula/core';
2
+ import type * as T11 from '@traqula/rules-sparql-1-1';
3
+ import { SparqlParser } from '@traqula/rules-sparql-1-1';
4
+ export declare const sparql11ParserBuilder: ParserBuilder<T11.SparqlContext, "string" | "object" | "filter" | "add" | "clear" | "copy" | "move" | "var" | "path" | "drop" | "load" | "update" | "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" | "graphRef" | "create" | "modify" | "query" | "datasetClauses" | "bind" | "solutionModifier" | "expression" | "aggregate" | "functionCall" | "blankNode" | "rdfLiteral" | "iri" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "iriFull" | "prefixedName" | "VerbA" | "usingClause" | "datasetClause" | "defaultGraphClause" | "namedGraphClause" | "sourceSelector" | "usingClauses" | "prologue" | "baseDecl" | "prefixDecl" | "verb" | "varOrIri" | "varOrTerm" | "graphTerm" | "pathAlternative" | "pathSequence" | "pathEltOrInverse" | "pathElt" | "pathMod" | "pathPrimary" | "pathNegatedPropertySet" | "pathOneInPropertySet" | "triplesBlock" | "triplesSameSubjectPath" | "propertyListPathNotEmpty" | "propertyListNotEmpty" | "triplesNodePath" | "triplesNode" | "propertyListPath" | "propertyList" | "triplesSameSubject" | "triplesTemplate" | "verbPath" | "verbSimple" | "objectList" | "objectListPath" | "graphNodePath" | "graphNode" | "objectPath" | "collection" | "collectionPath" | "blankNodePropertyListPath" | "blankNodePropertyList" | "whereClause" | "groupGraphPattern" | "subSelect" | "groupGraphPatternSub" | "graphPatternNotTriples" | "groupOrUnionGraphPattern" | "optionalGraphPattern" | "minusGraphPattern" | "graphGraphPattern" | "serviceGraphPattern" | "inlineData" | "dataBlock" | "inlineDataOneVar" | "inlineDataFull" | "dataBlockValue" | "constraint" | "brackettedExpression" | "builtInCall" | "argList" | "expressionList" | "conditionalOrExpression" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression" | "iriOrFunction" | "limitOffsetClauses" | "groupClause" | "havingClause" | "orderClause" | "groupCondition" | "havingCondition" | "orderCondition" | "limitClause" | "offsetClause" | "queryUnit" | "selectQuery" | "constructQuery" | "describeQuery" | "askQuery" | "valuesClause" | "selectClause" | "constructTemplate" | "constructTriples" | "updateUnit" | "update1" | "insertData" | "quadData" | "deleteData" | "deleteWhere" | "quadPattern" | "graphRefAll" | "graphOrDefault" | "quads" | "deleteClause" | "insertClause" | "quadsNotTriples" | "queryOrUpdate", {
5
+ string: import("@traqula/core").ParserRule<any, "string"> & T11.SparqlGrammarRule<"string", T11.TermLiteralStr>;
6
+ object: import("@traqula/core").ParserRule<any, "object"> & T11.SparqlGrammarRule<"object", T11.TripleNesting, Pick<T11.TripleNesting, "subject" | "predicate">>;
7
+ filter: import("@traqula/core").ParserRule<any, "filter"> & T11.SparqlGrammarRule<"filter", T11.PatternFilter, undefined> & T11.SparqlGeneratorRule<"filter", T11.PatternFilter, undefined>;
8
+ add: import("@traqula/core").ParserRule<any, "add"> & T11.SparqlGrammarRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined> & T11.SparqlGeneratorRule<"add", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined>;
9
+ clear: import("@traqula/core").ParserRule<any, "clear"> & T11.SparqlGrammarRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, undefined> & T11.SparqlGeneratorRule<"clear", T11.UpdateOperationClear | T11.UpdateOperationDrop, undefined>;
10
+ copy: import("@traqula/core").ParserRule<any, "copy"> & T11.SparqlGrammarRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined> & T11.SparqlGeneratorRule<"copy", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined>;
11
+ move: import("@traqula/core").ParserRule<any, "move"> & T11.SparqlGrammarRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined> & T11.SparqlGeneratorRule<"move", T11.UpdateOperationAdd | T11.UpdateOperationMove | T11.UpdateOperationCopy, undefined>;
12
+ var: import("@traqula/core").ParserRule<any, "var"> & T11.SparqlGrammarRule<"var", T11.TermVariable, undefined> & T11.SparqlGeneratorRule<"var", T11.TermVariable, undefined>;
13
+ path: import("@traqula/core").ParserRule<any, "path"> & T11.SparqlGrammarRule<"path", T11.Path>;
14
+ drop: import("@traqula/core").ParserRule<any, "drop"> & T11.SparqlGrammarRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, undefined> & T11.SparqlGeneratorRule<"drop", T11.UpdateOperationClear | T11.UpdateOperationDrop, undefined>;
15
+ load: import("@traqula/core").ParserRule<any, "load"> & T11.SparqlGrammarRule<"load", T11.UpdateOperationLoad, undefined> & T11.SparqlGeneratorRule<"load", T11.UpdateOperationLoad, undefined>;
16
+ update: import("@traqula/core").ParserRule<any, "update"> & T11.SparqlGrammarRule<"update", T11.Update, undefined> & T11.SparqlGeneratorRule<"update", T11.Update, undefined>;
17
+ builtInStr: import("@traqula/core").ParserRule<any, "builtInStr"> & T11.RuleDefExpressionFunctionX<"builtInStr", [T11.Expression]>;
18
+ builtInLang: import("@traqula/core").ParserRule<any, "builtInLang"> & T11.RuleDefExpressionFunctionX<"builtInLang", [T11.Expression]>;
19
+ builtInLangmatches: import("@traqula/core").ParserRule<any, "builtInLangmatches"> & T11.RuleDefExpressionFunctionX<"builtInLangmatches", [T11.Expression, T11.Expression]>;
20
+ builtInDatatype: import("@traqula/core").ParserRule<any, "builtInDatatype"> & T11.RuleDefExpressionFunctionX<"builtInDatatype", [T11.Expression]>;
21
+ builtInBound: import("@traqula/core").ParserRule<any, "builtInBound"> & T11.RuleDefExpressionFunctionX<"builtInBound", [T11.TermVariable]>;
22
+ builtInIri: import("@traqula/core").ParserRule<any, "builtInIri"> & T11.RuleDefExpressionFunctionX<"builtInIri", [T11.Expression]>;
23
+ builtInUri: import("@traqula/core").ParserRule<any, "builtInUri"> & T11.RuleDefExpressionFunctionX<"builtInUri", [T11.Expression]>;
24
+ builtInBnode: import("@traqula/core").ParserRule<any, "builtInBnode"> & T11.RuleDefExpressionFunctionX<"builtInBnode", [] | [T11.Expression]>;
25
+ builtInRand: import("@traqula/core").ParserRule<any, "builtInRand"> & T11.RuleDefExpressionFunctionX<"builtInRand", []>;
26
+ builtInAbs: import("@traqula/core").ParserRule<any, "builtInAbs"> & T11.RuleDefExpressionFunctionX<"builtInAbs", [T11.Expression]>;
27
+ builtInCeil: import("@traqula/core").ParserRule<any, "builtInCeil"> & T11.RuleDefExpressionFunctionX<"builtInCeil", [T11.Expression]>;
28
+ builtInFloor: import("@traqula/core").ParserRule<any, "builtInFloor"> & T11.RuleDefExpressionFunctionX<"builtInFloor", [T11.Expression]>;
29
+ builtInRound: import("@traqula/core").ParserRule<any, "builtInRound"> & T11.RuleDefExpressionFunctionX<"builtInRound", [T11.Expression]>;
30
+ builtInConcat: import("@traqula/core").ParserRule<any, "builtInConcat"> & T11.RuleDefExpressionFunctionX<"builtInConcat", T11.Expression[]>;
31
+ builtInStrlen: import("@traqula/core").ParserRule<any, "builtInStrlen"> & T11.RuleDefExpressionFunctionX<"builtInStrlen", [T11.Expression]>;
32
+ builtInUcase: import("@traqula/core").ParserRule<any, "builtInUcase"> & T11.RuleDefExpressionFunctionX<"builtInUcase", [T11.Expression]>;
33
+ builtInLcase: import("@traqula/core").ParserRule<any, "builtInLcase"> & T11.RuleDefExpressionFunctionX<"builtInLcase", [T11.Expression]>;
34
+ builtInEncode_for_uri: import("@traqula/core").ParserRule<any, "builtInEncode_for_uri"> & T11.RuleDefExpressionFunctionX<"builtInEncode_for_uri", [T11.Expression]>;
35
+ builtInContains: import("@traqula/core").ParserRule<any, "builtInContains"> & T11.RuleDefExpressionFunctionX<"builtInContains", [T11.Expression, T11.Expression]>;
36
+ builtInStrstarts: import("@traqula/core").ParserRule<any, "builtInStrstarts"> & T11.RuleDefExpressionFunctionX<"builtInStrstarts", [T11.Expression, T11.Expression]>;
37
+ builtInStrends: import("@traqula/core").ParserRule<any, "builtInStrends"> & T11.RuleDefExpressionFunctionX<"builtInStrends", [T11.Expression, T11.Expression]>;
38
+ builtInStrbefore: import("@traqula/core").ParserRule<any, "builtInStrbefore"> & T11.RuleDefExpressionFunctionX<"builtInStrbefore", [T11.Expression, T11.Expression]>;
39
+ builtInStrafter: import("@traqula/core").ParserRule<any, "builtInStrafter"> & T11.RuleDefExpressionFunctionX<"builtInStrafter", [T11.Expression, T11.Expression]>;
40
+ builtInYear: import("@traqula/core").ParserRule<any, "builtInYear"> & T11.RuleDefExpressionFunctionX<"builtInYear", [T11.Expression]>;
41
+ builtInMonth: import("@traqula/core").ParserRule<any, "builtInMonth"> & T11.RuleDefExpressionFunctionX<"builtInMonth", [T11.Expression]>;
42
+ builtInDay: import("@traqula/core").ParserRule<any, "builtInDay"> & T11.RuleDefExpressionFunctionX<"builtInDay", [T11.Expression]>;
43
+ builtInHours: import("@traqula/core").ParserRule<any, "builtInHours"> & T11.RuleDefExpressionFunctionX<"builtInHours", [T11.Expression]>;
44
+ builtInMinutes: import("@traqula/core").ParserRule<any, "builtInMinutes"> & T11.RuleDefExpressionFunctionX<"builtInMinutes", [T11.Expression]>;
45
+ builtInSeconds: import("@traqula/core").ParserRule<any, "builtInSeconds"> & T11.RuleDefExpressionFunctionX<"builtInSeconds", [T11.Expression]>;
46
+ builtInTimezone: import("@traqula/core").ParserRule<any, "builtInTimezone"> & T11.RuleDefExpressionFunctionX<"builtInTimezone", [T11.Expression]>;
47
+ builtInTz: import("@traqula/core").ParserRule<any, "builtInTz"> & T11.RuleDefExpressionFunctionX<"builtInTz", [T11.Expression]>;
48
+ builtInNow: import("@traqula/core").ParserRule<any, "builtInNow"> & T11.RuleDefExpressionFunctionX<"builtInNow", []>;
49
+ builtInUuid: import("@traqula/core").ParserRule<any, "builtInUuid"> & T11.RuleDefExpressionFunctionX<"builtInUuid", []>;
50
+ builtInStruuid: import("@traqula/core").ParserRule<any, "builtInStruuid"> & T11.RuleDefExpressionFunctionX<"builtInStruuid", []>;
51
+ builtInMd5: import("@traqula/core").ParserRule<any, "builtInMd5"> & T11.RuleDefExpressionFunctionX<"builtInMd5", [T11.Expression]>;
52
+ builtInSha1: import("@traqula/core").ParserRule<any, "builtInSha1"> & T11.RuleDefExpressionFunctionX<"builtInSha1", [T11.Expression]>;
53
+ builtInSha256: import("@traqula/core").ParserRule<any, "builtInSha256"> & T11.RuleDefExpressionFunctionX<"builtInSha256", [T11.Expression]>;
54
+ builtInSha384: import("@traqula/core").ParserRule<any, "builtInSha384"> & T11.RuleDefExpressionFunctionX<"builtInSha384", [T11.Expression]>;
55
+ builtInSha512: import("@traqula/core").ParserRule<any, "builtInSha512"> & T11.RuleDefExpressionFunctionX<"builtInSha512", [T11.Expression]>;
56
+ builtInCoalesce: import("@traqula/core").ParserRule<any, "builtInCoalesce"> & T11.RuleDefExpressionFunctionX<"builtInCoalesce", T11.Expression[]>;
57
+ builtInIf: import("@traqula/core").ParserRule<any, "builtInIf"> & T11.RuleDefExpressionFunctionX<"builtInIf", [T11.Expression, T11.Expression, T11.Expression]>;
58
+ builtInStrlang: import("@traqula/core").ParserRule<any, "builtInStrlang"> & T11.RuleDefExpressionFunctionX<"builtInStrlang", [T11.Expression, T11.Expression]>;
59
+ builtInStrdt: import("@traqula/core").ParserRule<any, "builtInStrdt"> & T11.RuleDefExpressionFunctionX<"builtInStrdt", [T11.Expression, T11.Expression]>;
60
+ builtInSameterm: import("@traqula/core").ParserRule<any, "builtInSameterm"> & T11.RuleDefExpressionFunctionX<"builtInSameterm", [T11.Expression, T11.Expression]>;
61
+ builtInIsiri: import("@traqula/core").ParserRule<any, "builtInIsiri"> & T11.RuleDefExpressionFunctionX<"builtInIsiri", [T11.Expression]>;
62
+ builtInIsuri: import("@traqula/core").ParserRule<any, "builtInIsuri"> & T11.RuleDefExpressionFunctionX<"builtInIsuri", [T11.Expression]>;
63
+ builtInIsblank: import("@traqula/core").ParserRule<any, "builtInIsblank"> & T11.RuleDefExpressionFunctionX<"builtInIsblank", [T11.Expression]>;
64
+ builtInIsliteral: import("@traqula/core").ParserRule<any, "builtInIsliteral"> & T11.RuleDefExpressionFunctionX<"builtInIsliteral", [T11.Expression]>;
65
+ builtInIsnumeric: import("@traqula/core").ParserRule<any, "builtInIsnumeric"> & T11.RuleDefExpressionFunctionX<"builtInIsnumeric", [T11.Expression]>;
66
+ builtInRegex: import("@traqula/core").ParserRule<any, "builtInRegex"> & T11.RuleDefExpressionFunctionX<"builtInRegex", [T11.Expression, T11.Expression] | [T11.Expression, T11.Expression, T11.Expression]>;
67
+ builtInSubstr: import("@traqula/core").ParserRule<any, "builtInSubstr"> & T11.RuleDefExpressionFunctionX<"builtInSubstr", [T11.Expression, T11.Expression] | [T11.Expression, T11.Expression, T11.Expression]>;
68
+ builtInReplace: import("@traqula/core").ParserRule<any, "builtInReplace"> & T11.RuleDefExpressionFunctionX<"builtInReplace", [T11.Expression, T11.Expression, T11.Expression] | [T11.Expression, T11.Expression, T11.Expression, T11.Expression]>;
69
+ builtInExists: import("@traqula/core").ParserRule<any, "builtInExists"> & T11.SparqlGrammarRule<"builtInExists", T11.ExpressionPatternOperation>;
70
+ builtInNotexists: import("@traqula/core").ParserRule<any, "builtInNotexists"> & T11.SparqlGrammarRule<"builtInNotexists", T11.ExpressionPatternOperation>;
71
+ builtInCount: import("@traqula/core").ParserRule<any, "builtInCount"> & T11.SparqlGrammarRule<"builtInCount", T11.ExpressionAggregateDefault | T11.ExpressionAggregateOnWildcard>;
72
+ builtInSum: import("@traqula/core").ParserRule<any, "builtInSum"> & T11.RuleDefExpressionAggregatorX<"builtInSum">;
73
+ builtInMin: import("@traqula/core").ParserRule<any, "builtInMin"> & T11.RuleDefExpressionAggregatorX<"builtInMin">;
74
+ builtInMax: import("@traqula/core").ParserRule<any, "builtInMax"> & T11.RuleDefExpressionAggregatorX<"builtInMax">;
75
+ builtInAvg: import("@traqula/core").ParserRule<any, "builtInAvg"> & T11.RuleDefExpressionAggregatorX<"builtInAvg">;
76
+ builtInSample: import("@traqula/core").ParserRule<any, "builtInSample"> & T11.RuleDefExpressionAggregatorX<"builtInSample">;
77
+ builtInGroup_concat: import("@traqula/core").ParserRule<any, "builtInGroup_concat"> & T11.SparqlGrammarRule<"builtInGroup_concat", T11.ExpressionAggregateDefault | T11.ExpressionAggregateSeparator>;
78
+ graphRef: import("@traqula/core").ParserRule<any, "graphRef"> & T11.SparqlGrammarRule<"graphRef", T11.GraphRefSpecific, undefined> & T11.SparqlGeneratorRule<"graphRef", T11.GraphRefSpecific, undefined>;
79
+ create: import("@traqula/core").ParserRule<any, "create"> & T11.SparqlGrammarRule<"create", T11.UpdateOperationCreate, undefined> & T11.SparqlGeneratorRule<"create", T11.UpdateOperationCreate, undefined>;
80
+ modify: import("@traqula/core").ParserRule<any, "modify"> & T11.SparqlGrammarRule<"modify", T11.UpdateOperationModify, undefined> & T11.SparqlGeneratorRule<"modify", T11.UpdateOperationModify, undefined>;
81
+ query: import("@traqula/core").ParserRule<any, "query"> & T11.SparqlGrammarRule<"query", T11.Query, undefined> & T11.SparqlGeneratorRule<"query", T11.Query, undefined>;
82
+ datasetClauses: import("@traqula/core").ParserRule<T11.SparqlContext, "datasetClauses", T11.DatasetClauses, undefined>;
83
+ bind: import("@traqula/core").ParserRule<any, "bind"> & T11.SparqlGrammarRule<"bind", T11.PatternBind, undefined> & T11.SparqlGeneratorRule<"bind", T11.PatternBind, undefined>;
84
+ solutionModifier: import("@traqula/core").ParserRule<any, "solutionModifier"> & T11.SparqlGrammarRule<"solutionModifier", T11.SolutionModifiers, undefined> & T11.SparqlGeneratorRule<"solutionModifier", T11.SolutionModifiers, undefined>;
85
+ expression: import("@traqula/core").ParserRule<any, "expression"> & T11.SparqlGrammarRule<"expression", T11.Expression, undefined> & T11.SparqlGeneratorRule<"expression", T11.Expression, undefined>;
86
+ aggregate: import("@traqula/core").ParserRule<any, "aggregate"> & T11.SparqlGrammarRule<"aggregate", T11.ExpressionAggregate, undefined> & T11.SparqlGeneratorRule<"aggregate", T11.ExpressionAggregate, undefined>;
87
+ functionCall: import("@traqula/core").ParserRule<any, "functionCall"> & T11.SparqlGrammarRule<"functionCall", T11.ExpressionFunctionCall>;
88
+ blankNode: import("@traqula/core").ParserRule<any, "blankNode"> & T11.SparqlGrammarRule<"blankNode", T11.TermBlank, undefined> & T11.SparqlGeneratorRule<"blankNode", T11.TermBlank, undefined>;
89
+ rdfLiteral: import("@traqula/core").ParserRule<any, "rdfLiteral"> & T11.SparqlGrammarRule<"rdfLiteral", T11.TermLiteral, undefined> & T11.SparqlGeneratorRule<"rdfLiteral", T11.TermLiteral, undefined>;
90
+ iri: import("@traqula/core").ParserRule<any, "iri"> & T11.SparqlGrammarRule<"iri", T11.TermIri, undefined> & T11.SparqlGeneratorRule<"iri", T11.TermIri, undefined>;
91
+ numericLiteral: import("@traqula/core").ParserRule<any, "numericLiteral"> & T11.SparqlGrammarRule<"numericLiteral", T11.TermLiteralTyped>;
92
+ numericLiteralUnsigned: import("@traqula/core").ParserRule<any, "numericLiteralUnsigned"> & T11.SparqlGrammarRule<"numericLiteralUnsigned", T11.TermLiteralTyped>;
93
+ numericLiteralPositive: import("@traqula/core").ParserRule<any, "numericLiteralPositive"> & T11.SparqlGrammarRule<"numericLiteralPositive", T11.TermLiteralTyped>;
94
+ numericLiteralNegative: import("@traqula/core").ParserRule<any, "numericLiteralNegative"> & T11.SparqlGrammarRule<"numericLiteralNegative", T11.TermLiteralTyped>;
95
+ booleanLiteral: import("@traqula/core").ParserRule<any, "booleanLiteral"> & T11.SparqlGrammarRule<"booleanLiteral", T11.TermLiteralTyped>;
96
+ iriFull: import("@traqula/core").ParserRule<any, "iriFull"> & T11.SparqlGrammarRule<"iriFull", T11.TermIriFull, undefined> & T11.SparqlGeneratorRule<"iriFull", T11.TermIriFull, undefined>;
97
+ prefixedName: import("@traqula/core").ParserRule<any, "prefixedName"> & T11.SparqlGrammarRule<"prefixedName", T11.TermIriPrefixed, undefined> & T11.SparqlGeneratorRule<"prefixedName", T11.TermIriPrefixed, undefined>;
98
+ VerbA: import("@traqula/core").ParserRule<any, "VerbA"> & T11.SparqlGrammarRule<"VerbA", T11.TermIriFull>;
99
+ usingClause: import("@traqula/core").ParserRule<any, "usingClause"> & T11.SparqlGrammarRule<"usingClause", import("@traqula/core").Wrap<{
100
+ clauseType: "default" | "named";
101
+ value: T11.TermIri;
102
+ }>>;
103
+ datasetClause: import("@traqula/core").ParserRule<T11.SparqlContext, "datasetClause", import("@traqula/core").Wrap<{
104
+ clauseType: "default" | "named";
105
+ value: T11.TermIri;
106
+ }>, undefined>;
107
+ defaultGraphClause: import("@traqula/core").ParserRule<T11.SparqlContext, "defaultGraphClause", T11.TermIri, undefined>;
108
+ namedGraphClause: import("@traqula/core").ParserRule<T11.SparqlContext, "namedGraphClause", import("@traqula/core").Wrap<T11.TermIri>, undefined>;
109
+ sourceSelector: import("@traqula/core").ParserRule<T11.SparqlContext, "sourceSelector", T11.TermIri, undefined>;
110
+ usingClauses: import("@traqula/core").ParserRule<any, "usingClauses"> & T11.SparqlGrammarRule<"usingClauses", T11.DatasetClauses, undefined> & T11.SparqlGeneratorRule<"usingClauses", T11.DatasetClauses, undefined>;
111
+ prologue: import("@traqula/core").ParserRule<any, "prologue"> & T11.SparqlGrammarRule<"prologue", T11.ContextDefinition[], undefined> & T11.SparqlGeneratorRule<"prologue", T11.ContextDefinition[], undefined>;
112
+ baseDecl: import("@traqula/core").ParserRule<any, "baseDecl"> & T11.SparqlGrammarRule<"baseDecl", T11.ContextDefinitionBase, undefined> & T11.SparqlGeneratorRule<"baseDecl", T11.ContextDefinitionBase, undefined>;
113
+ prefixDecl: import("@traqula/core").ParserRule<any, "prefixDecl"> & T11.SparqlGrammarRule<"prefixDecl", T11.ContextDefinitionPrefix, undefined> & T11.SparqlGeneratorRule<"prefixDecl", T11.ContextDefinitionPrefix, undefined>;
114
+ verb: import("@traqula/core").ParserRule<any, "verb"> & T11.SparqlGrammarRule<"verb", T11.TermIri | T11.TermVariable>;
115
+ varOrIri: import("@traqula/core").ParserRule<any, "varOrIri"> & T11.SparqlGrammarRule<"varOrIri", T11.TermIri | T11.TermVariable>;
116
+ varOrTerm: import("@traqula/core").ParserRule<any, "varOrTerm"> & T11.SparqlGrammarRule<"varOrTerm", T11.Term, undefined> & T11.SparqlGeneratorRule<"varOrTerm", T11.Term, undefined>;
117
+ graphTerm: import("@traqula/core").ParserRule<any, "graphTerm"> & T11.SparqlGrammarRule<"graphTerm", T11.GraphTerm, undefined> & T11.SparqlGeneratorRule<"graphTerm", T11.GraphTerm, undefined>;
118
+ pathAlternative: import("@traqula/core").ParserRule<any, "pathAlternative"> & T11.SparqlGrammarRule<"pathAlternative", T11.TermIriFull | T11.TermIriPrefixed | T11.PropertyPathChain | T11.PathModified | T11.PathNegated>;
119
+ pathSequence: import("@traqula/core").ParserRule<any, "pathSequence"> & T11.SparqlGrammarRule<"pathSequence", T11.TermIriFull | T11.TermIriPrefixed | T11.PropertyPathChain | T11.PathModified | T11.PathNegated>;
120
+ pathEltOrInverse: import("@traqula/core").ParserRule<any, "pathEltOrInverse"> & T11.SparqlGrammarRule<"pathEltOrInverse", T11.Path>;
121
+ pathElt: import("@traqula/core").ParserRule<any, "pathElt"> & T11.SparqlGrammarRule<"pathElt", T11.Path>;
122
+ pathMod: import("@traqula/core").ParserRule<any, "pathMod"> & T11.SparqlGrammarRule<"pathMod", import("chevrotain").IToken & {
123
+ image: "*" | "+" | "?";
124
+ }>;
125
+ pathPrimary: import("@traqula/core").ParserRule<any, "pathPrimary"> & T11.SparqlGrammarRule<"pathPrimary", T11.Path>;
126
+ pathNegatedPropertySet: import("@traqula/core").ParserRule<any, "pathNegatedPropertySet"> & T11.SparqlGrammarRule<"pathNegatedPropertySet", T11.PathNegated>;
127
+ pathOneInPropertySet: import("@traqula/core").ParserRule<any, "pathOneInPropertySet"> & T11.SparqlGrammarRule<"pathOneInPropertySet", T11.TermIri | T11.PathNegatedElt>;
128
+ triplesBlock: import("@traqula/core").ParserRule<any, "triplesBlock"> & T11.SparqlGrammarRule<"triplesBlock", T11.PatternBgp, undefined> & T11.SparqlGeneratorRule<"triplesBlock", T11.PatternBgp, undefined>;
129
+ triplesSameSubjectPath: import("@traqula/core").ParserRule<any, "triplesSameSubjectPath"> & T11.SparqlGrammarRule<"triplesSameSubjectPath", T11.BasicGraphPattern>;
130
+ propertyListPathNotEmpty: import("@traqula/core").ParserRule<any, "propertyListPathNotEmpty"> & T11.SparqlGrammarRule<"propertyListPathNotEmpty", T11.TripleNesting[], Pick<T11.TripleNesting, "subject">>;
131
+ propertyListNotEmpty: import("@traqula/core").ParserRule<any, "propertyListNotEmpty"> & T11.SparqlGrammarRule<"propertyListNotEmpty", T11.TripleNesting[], Pick<T11.TripleNesting, "subject">>;
132
+ triplesNodePath: import("@traqula/core").ParserRule<any, "triplesNodePath"> & T11.SparqlGrammarRule<"triplesNodePath", T11.TripleCollection, undefined> & T11.SparqlGeneratorRule<"triplesNodePath", T11.TripleCollection, undefined>;
133
+ triplesNode: import("@traqula/core").ParserRule<any, "triplesNode"> & T11.SparqlGrammarRule<"triplesNode", T11.TripleCollection, undefined> & T11.SparqlGeneratorRule<"triplesNode", T11.TripleCollection, undefined>;
134
+ propertyListPath: import("@traqula/core").ParserRule<any, "propertyListPath"> & T11.SparqlGrammarRule<"propertyListPath", T11.TripleNesting[], Pick<T11.TripleNesting, "subject">>;
135
+ propertyList: import("@traqula/core").ParserRule<any, "propertyList"> & T11.SparqlGrammarRule<"propertyList", T11.TripleNesting[], Pick<T11.TripleNesting, "subject">>;
136
+ triplesSameSubject: import("@traqula/core").ParserRule<any, "triplesSameSubject"> & T11.SparqlGrammarRule<"triplesSameSubject", T11.BasicGraphPattern>;
137
+ triplesTemplate: import("@traqula/core").ParserRule<any, "triplesTemplate"> & T11.SparqlGrammarRule<"triplesTemplate", T11.PatternBgp>;
138
+ verbPath: import("@traqula/core").ParserRule<any, "verbPath"> & T11.SparqlGrammarRule<"verbPath", T11.Path>;
139
+ verbSimple: import("@traqula/core").ParserRule<any, "verbSimple"> & T11.SparqlGrammarRule<"verbSimple", T11.TermVariable>;
140
+ objectList: import("@traqula/core").ParserRule<any, "objectList"> & T11.SparqlGrammarRule<"objectList", T11.TripleNesting[], Pick<T11.TripleNesting, "subject" | "predicate">>;
141
+ objectListPath: import("@traqula/core").ParserRule<any, "objectListPath"> & T11.SparqlGrammarRule<"objectListPath", T11.TripleNesting[], Pick<T11.TripleNesting, "subject" | "predicate">>;
142
+ graphNodePath: import("@traqula/core").ParserRule<any, "graphNodePath"> & T11.SparqlGrammarRule<"graphNodePath", T11.TripleCollection | T11.Term, undefined> & T11.SparqlGeneratorRule<"graphNodePath", T11.TripleCollection | T11.Term, undefined>;
143
+ graphNode: import("@traqula/core").ParserRule<any, "graphNode"> & T11.SparqlGrammarRule<"graphNode", T11.TripleCollection | T11.Term, undefined> & T11.SparqlGeneratorRule<"graphNode", T11.TripleCollection | T11.Term, undefined>;
144
+ objectPath: import("@traqula/core").ParserRule<any, "objectPath"> & T11.SparqlGrammarRule<"objectPath", T11.TripleNesting, Pick<T11.TripleNesting, "subject" | "predicate">>;
145
+ collection: import("@traqula/core").ParserRule<any, "collection"> & T11.SparqlGrammarRule<"collection", T11.TripleCollectionList, undefined> & T11.SparqlGeneratorRule<"collection", T11.TripleCollectionList, undefined>;
146
+ collectionPath: import("@traqula/core").ParserRule<any, "collectionPath"> & T11.SparqlGrammarRule<"collectionPath", T11.TripleCollectionList, undefined> & T11.SparqlGeneratorRule<"collectionPath", T11.TripleCollectionList, undefined>;
147
+ blankNodePropertyListPath: import("@traqula/core").ParserRule<any, "blankNodePropertyListPath"> & T11.SparqlGrammarRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, undefined> & T11.SparqlGeneratorRule<"blankNodePropertyListPath", T11.TripleCollectionBlankNodeProperties, undefined>;
148
+ blankNodePropertyList: import("@traqula/core").ParserRule<any, "blankNodePropertyList"> & T11.SparqlGrammarRule<"blankNodePropertyList", T11.TripleCollectionBlankNodeProperties, undefined> & T11.SparqlGeneratorRule<"blankNodePropertyList", T11.TripleCollectionBlankNodeProperties, undefined>;
149
+ whereClause: import("@traqula/core").ParserRule<any, "whereClause"> & T11.SparqlGrammarRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, undefined> & T11.SparqlGeneratorRule<"whereClause", import("@traqula/core").Wrap<T11.PatternGroup>, undefined>;
150
+ groupGraphPattern: import("@traqula/core").ParserRule<any, "groupGraphPattern"> & T11.SparqlGrammarRule<"groupGraphPattern", T11.PatternGroup, undefined> & T11.SparqlGeneratorRule<"groupGraphPattern", T11.PatternGroup, undefined>;
151
+ subSelect: import("@traqula/core").ParserRule<any, "subSelect"> & T11.SparqlGrammarRule<"subSelect", T11.QuerySelect>;
152
+ groupGraphPatternSub: import("@traqula/core").ParserRule<any, "groupGraphPatternSub"> & T11.SparqlGrammarRule<"groupGraphPatternSub", T11.Pattern[]>;
153
+ graphPatternNotTriples: import("@traqula/core").ParserRule<any, "graphPatternNotTriples"> & T11.SparqlGrammarRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, undefined> & T11.SparqlGeneratorRule<"graphPatternNotTriples", T11.PatternGroup | T11.PatternUnion | T11.PatternOptional | T11.PatternMinus | T11.PatternGraph | T11.PatternService | T11.PatternFilter | T11.PatternBind | T11.PatternValues, undefined>;
154
+ groupOrUnionGraphPattern: import("@traqula/core").ParserRule<any, "groupOrUnionGraphPattern"> & T11.SparqlGrammarRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, undefined> & T11.SparqlGeneratorRule<"groupOrUnionGraphPattern", T11.PatternGroup | T11.PatternUnion, undefined>;
155
+ optionalGraphPattern: import("@traqula/core").ParserRule<any, "optionalGraphPattern"> & T11.SparqlGrammarRule<"optionalGraphPattern", T11.PatternOptional, undefined> & T11.SparqlGeneratorRule<"optionalGraphPattern", T11.PatternOptional, undefined>;
156
+ minusGraphPattern: import("@traqula/core").ParserRule<any, "minusGraphPattern"> & T11.SparqlGrammarRule<"minusGraphPattern", T11.PatternMinus, undefined> & T11.SparqlGeneratorRule<"minusGraphPattern", T11.PatternMinus, undefined>;
157
+ graphGraphPattern: import("@traqula/core").ParserRule<any, "graphGraphPattern"> & T11.SparqlGrammarRule<"graphGraphPattern", T11.PatternGraph, undefined> & T11.SparqlGeneratorRule<"graphGraphPattern", T11.PatternGraph, undefined>;
158
+ serviceGraphPattern: import("@traqula/core").ParserRule<any, "serviceGraphPattern"> & T11.SparqlGrammarRule<"serviceGraphPattern", T11.PatternService, undefined> & T11.SparqlGeneratorRule<"serviceGraphPattern", T11.PatternService, undefined>;
159
+ inlineData: import("@traqula/core").ParserRule<any, "inlineData"> & T11.SparqlGrammarRule<"inlineData", T11.PatternValues, undefined> & T11.SparqlGeneratorRule<"inlineData", T11.PatternValues, undefined>;
160
+ dataBlock: import("@traqula/core").ParserRule<any, "dataBlock"> & T11.SparqlGrammarRule<"dataBlock", import("@traqula/core").Wrap<T11.ValuePatternRow[]>>;
161
+ inlineDataOneVar: import("@traqula/core").ParserRule<any, "inlineDataOneVar"> & T11.SparqlGrammarRule<"inlineDataOneVar", import("@traqula/core").Wrap<T11.ValuePatternRow[]>>;
162
+ inlineDataFull: import("@traqula/core").ParserRule<any, "inlineDataFull"> & T11.SparqlGrammarRule<"inlineDataFull", import("@traqula/core").Wrap<T11.ValuePatternRow[]>>;
163
+ dataBlockValue: import("@traqula/core").ParserRule<any, "dataBlockValue"> & T11.SparqlGrammarRule<"dataBlockValue", T11.TermIri | T11.TermLiteral | undefined>;
164
+ constraint: import("@traqula/core").ParserRule<any, "constraint"> & T11.SparqlGrammarRule<"constraint", T11.Expression>;
165
+ brackettedExpression: import("@traqula/core").ParserRule<any, "brackettedExpression"> & T11.SparqlGrammarRule<"brackettedExpression", T11.Expression>;
166
+ builtInCall: import("@traqula/core").ParserRule<T11.SparqlContext, "builtInCall", T11.Expression, undefined>;
167
+ argList: import("@traqula/core").ParserRule<any, "argList"> & T11.SparqlGrammarRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, undefined> & T11.SparqlGeneratorRule<"argList", import("@traqula/core").Wrap<T11.gram.IArgList>, undefined>;
168
+ expressionList: import("@traqula/core").ParserRule<any, "expressionList"> & T11.SparqlGrammarRule<"expressionList", import("@traqula/core").Wrap<T11.Expression[]>>;
169
+ conditionalOrExpression: import("@traqula/core").ParserRule<any, "conditionalOrExpression"> & T11.SparqlGrammarRule<"conditionalOrExpression", T11.Expression>;
170
+ conditionalAndExpression: import("@traqula/core").ParserRule<any, "conditionalAndExpression"> & T11.SparqlGrammarRule<"conditionalAndExpression", T11.Expression>;
171
+ valueLogical: import("@traqula/core").ParserRule<any, "valueLogical"> & T11.SparqlGrammarRule<"valueLogical", T11.Expression>;
172
+ relationalExpression: import("@traqula/core").ParserRule<any, "relationalExpression"> & T11.SparqlGrammarRule<"relationalExpression", T11.Expression>;
173
+ numericExpression: import("@traqula/core").ParserRule<any, "numericExpression"> & T11.SparqlGrammarRule<"numericExpression", T11.Expression>;
174
+ additiveExpression: import("@traqula/core").ParserRule<any, "additiveExpression"> & T11.SparqlGrammarRule<"additiveExpression", T11.Expression>;
175
+ multiplicativeExpression: import("@traqula/core").ParserRule<any, "multiplicativeExpression"> & T11.SparqlGrammarRule<"multiplicativeExpression", T11.Expression>;
176
+ unaryExpression: import("@traqula/core").ParserRule<any, "unaryExpression"> & T11.SparqlGrammarRule<"unaryExpression", T11.Expression>;
177
+ primaryExpression: import("@traqula/core").ParserRule<any, "primaryExpression"> & T11.SparqlGrammarRule<"primaryExpression", T11.Expression>;
178
+ iriOrFunction: import("@traqula/core").ParserRule<any, "iriOrFunction"> & T11.SparqlGrammarRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, undefined> & T11.SparqlGeneratorRule<"iriOrFunction", T11.ExpressionFunctionCall | T11.TermIri, undefined>;
179
+ limitOffsetClauses: import("@traqula/core").ParserRule<any, "limitOffsetClauses"> & T11.SparqlGrammarRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, undefined> & T11.SparqlGeneratorRule<"limitOffsetClauses", T11.SolutionModifierLimitOffset, undefined>;
180
+ groupClause: import("@traqula/core").ParserRule<any, "groupClause"> & T11.SparqlGrammarRule<"groupClause", T11.SolutionModifierGroup, undefined> & T11.SparqlGeneratorRule<"groupClause", T11.SolutionModifierGroup, undefined>;
181
+ havingClause: import("@traqula/core").ParserRule<any, "havingClause"> & T11.SparqlGrammarRule<"havingClause", T11.SolutionModifierHaving, undefined> & T11.SparqlGeneratorRule<"havingClause", T11.SolutionModifierHaving, undefined>;
182
+ orderClause: import("@traqula/core").ParserRule<any, "orderClause"> & T11.SparqlGrammarRule<"orderClause", T11.SolutionModifierOrder, undefined> & T11.SparqlGeneratorRule<"orderClause", T11.SolutionModifierOrder, undefined>;
183
+ groupCondition: import("@traqula/core").ParserRule<any, "groupCondition"> & T11.SparqlGrammarRule<"groupCondition", T11.Expression | T11.SolutionModifierGroupBind>;
184
+ havingCondition: import("@traqula/core").ParserRule<any, "havingCondition"> & T11.SparqlGrammarRule<"havingCondition", T11.Expression>;
185
+ orderCondition: import("@traqula/core").ParserRule<any, "orderCondition"> & T11.SparqlGrammarRule<"orderCondition", T11.Ordering>;
186
+ limitClause: import("@traqula/core").ParserRule<any, "limitClause"> & T11.SparqlGrammarRule<"limitClause", import("@traqula/core").Wrap<number>>;
187
+ offsetClause: import("@traqula/core").ParserRule<any, "offsetClause"> & T11.SparqlGrammarRule<"offsetClause", import("@traqula/core").Wrap<number>>;
188
+ queryUnit: import("@traqula/core").ParserRule<any, "queryUnit"> & T11.SparqlGrammarRule<"queryUnit", T11.Query>;
189
+ selectQuery: import("@traqula/core").ParserRule<any, "selectQuery"> & T11.SparqlGrammarRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, undefined> & T11.SparqlGeneratorRule<"selectQuery", Omit<T11.QuerySelect, T11.gram.HandledByBase>, undefined>;
190
+ constructQuery: import("@traqula/core").ParserRule<any, "constructQuery"> & T11.SparqlGrammarRule<"constructQuery", Omit<T11.QueryConstruct, T11.gram.HandledByBase>, undefined> & T11.SparqlGeneratorRule<"constructQuery", Omit<T11.QueryConstruct, T11.gram.HandledByBase>, undefined>;
191
+ describeQuery: import("@traqula/core").ParserRule<any, "describeQuery"> & T11.SparqlGrammarRule<"describeQuery", Omit<T11.QueryDescribe, T11.gram.HandledByBase>, undefined> & T11.SparqlGeneratorRule<"describeQuery", Omit<T11.QueryDescribe, T11.gram.HandledByBase>, undefined>;
192
+ askQuery: import("@traqula/core").ParserRule<any, "askQuery"> & T11.SparqlGrammarRule<"askQuery", Omit<T11.QueryAsk, T11.gram.HandledByBase>, undefined> & T11.SparqlGeneratorRule<"askQuery", Omit<T11.QueryAsk, T11.gram.HandledByBase>, undefined>;
193
+ valuesClause: import("@traqula/core").ParserRule<any, "valuesClause"> & T11.SparqlGrammarRule<"valuesClause", T11.PatternValues | undefined>;
194
+ selectClause: import("@traqula/core").ParserRule<any, "selectClause"> & T11.SparqlGrammarRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "distinct" | "variables" | "reduced">>, undefined> & T11.SparqlGeneratorRule<"selectClause", import("@traqula/core").Wrap<Pick<T11.QuerySelect, "distinct" | "variables" | "reduced">>, undefined>;
195
+ constructTemplate: import("@traqula/core").ParserRule<T11.SparqlContext, "constructTemplate", import("@traqula/core").Wrap<T11.PatternBgp>, undefined>;
196
+ constructTriples: import("@traqula/core").ParserRule<T11.SparqlContext, "constructTriples", T11.PatternBgp, undefined>;
197
+ updateUnit: import("@traqula/core").ParserRule<any, "updateUnit"> & T11.SparqlGrammarRule<"updateUnit", T11.Update>;
198
+ update1: import("@traqula/core").ParserRule<T11.SparqlContext, "update1", T11.UpdateOperation, undefined>;
199
+ insertData: import("@traqula/core").ParserRule<any, "insertData"> & T11.SparqlGrammarRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined> & T11.SparqlGeneratorRule<"insertData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined>;
200
+ quadData: import("@traqula/core").ParserRule<any, "quadData"> & T11.SparqlGrammarRule<"quadData", import("@traqula/core").Wrap<T11.Quads[]>>;
201
+ deleteData: import("@traqula/core").ParserRule<any, "deleteData"> & T11.SparqlGrammarRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined> & T11.SparqlGeneratorRule<"deleteData", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined>;
202
+ deleteWhere: import("@traqula/core").ParserRule<any, "deleteWhere"> & T11.SparqlGrammarRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined> & T11.SparqlGeneratorRule<"deleteWhere", T11.UpdateOperationInsertData | T11.UpdateOperationDeleteData | T11.UpdateOperationDeleteWhere, undefined>;
203
+ quadPattern: import("@traqula/core").ParserRule<T11.SparqlContext, "quadPattern", import("@traqula/core").Wrap<T11.Quads[]>, undefined>;
204
+ graphRefAll: import("@traqula/core").ParserRule<any, "graphRefAll"> & T11.SparqlGrammarRule<"graphRefAll", T11.GraphRef, undefined> & T11.SparqlGeneratorRule<"graphRefAll", T11.GraphRef, undefined>;
205
+ graphOrDefault: import("@traqula/core").ParserRule<any, "graphOrDefault"> & T11.SparqlGrammarRule<"graphOrDefault", T11.GraphRefDefault | T11.GraphRefSpecific>;
206
+ quads: import("@traqula/core").ParserRule<any, "quads"> & T11.SparqlGrammarRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, undefined> & T11.SparqlGeneratorRule<"quads", import("@traqula/core").Wrap<T11.Quads[]>, undefined>;
207
+ deleteClause: import("@traqula/core").ParserRule<any, "deleteClause"> & T11.SparqlGrammarRule<"deleteClause", import("@traqula/core").Wrap<T11.Quads[]>>;
208
+ insertClause: import("@traqula/core").ParserRule<any, "insertClause"> & T11.SparqlGrammarRule<"insertClause", import("@traqula/core").Wrap<T11.Quads[]>>;
209
+ quadsNotTriples: import("@traqula/core").ParserRule<T11.SparqlContext, "quadsNotTriples", T11.GraphQuads, undefined>;
210
+ queryOrUpdate: import("@traqula/core").ParserRule<T11.SparqlContext, "queryOrUpdate", T11.SparqlQuery, undefined>;
211
+ }>;
212
+ export declare class Parser extends SparqlParser<T11.SparqlQuery> {
213
+ constructor();
214
+ }
package/lib/Parser.js ADDED
@@ -0,0 +1,72 @@
1
+ import { ParserBuilder } from '@traqula/core';
2
+ import { sparqlCodepointEscape, lex as l, SparqlParser, gram, updateNoReuseBlankNodeLabels, } from '@traqula/rules-sparql-1-1';
3
+ import { queryUnitParserBuilder } from './queryUnitParser';
4
+ import { updateParserBuilder } from './updateUnitParser';
5
+ /**
6
+ * Query or update, optimized for the Query case.
7
+ * One could implement a new rule that does not use BACKTRACK.
8
+ */
9
+ const queryOrUpdate = {
10
+ name: 'queryOrUpdate',
11
+ impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {
12
+ const prologueValues = SUBRULE(gram.prologue, undefined);
13
+ return OR1([
14
+ { ALT: () => {
15
+ const subType = OR2([
16
+ { ALT: () => SUBRULE(gram.selectQuery, undefined) },
17
+ { ALT: () => SUBRULE(gram.constructQuery, undefined) },
18
+ { ALT: () => SUBRULE(gram.describeQuery, undefined) },
19
+ { ALT: () => SUBRULE(gram.askQuery, undefined) },
20
+ ]);
21
+ const values = SUBRULE(gram.valuesClause, undefined);
22
+ return ACTION(() => ({
23
+ context: prologueValues,
24
+ ...subType,
25
+ type: 'query',
26
+ ...(values && { values }),
27
+ loc: C.factory.sourceLocation(prologueValues.at(0), subType, values),
28
+ }));
29
+ } },
30
+ { ALT: () => {
31
+ const updates = [];
32
+ updates.push({ context: prologueValues });
33
+ let parsedSemi = true;
34
+ MANY({
35
+ GATE: () => parsedSemi,
36
+ DEF: () => {
37
+ parsedSemi = false;
38
+ updates.at(-1).operation = SUBRULE(gram.update1, undefined);
39
+ OPTION1(() => {
40
+ CONSUME(l.symbols.semi);
41
+ parsedSemi = true;
42
+ const innerPrologue = SUBRULE2(gram.prologue, undefined);
43
+ updates.push({ context: innerPrologue });
44
+ });
45
+ },
46
+ });
47
+ return ACTION(() => {
48
+ const update = {
49
+ type: 'update',
50
+ updates,
51
+ loc: C.factory.sourceLocation(...updates[0].context, updates[0].operation, ...updates.at(-1).context, updates.at(-1)?.operation),
52
+ };
53
+ updateNoReuseBlankNodeLabels(update);
54
+ return update;
55
+ });
56
+ } },
57
+ ]);
58
+ },
59
+ };
60
+ export const sparql11ParserBuilder = ParserBuilder.create(queryUnitParserBuilder)
61
+ .merge(updateParserBuilder, [])
62
+ .addRule(queryOrUpdate);
63
+ export class Parser extends SparqlParser {
64
+ constructor() {
65
+ const parser = sparql11ParserBuilder.build({
66
+ tokenVocabulary: l.sparql11Tokens.tokenVocabulary,
67
+ queryPreProcessor: sparqlCodepointEscape,
68
+ });
69
+ super(parser);
70
+ }
71
+ }
72
+ //# sourceMappingURL=Parser.js.map
package/lib/Parser.js.map ADDED
@@ -0,0 +1 @@
1
+ {"version":3,"file":"Parser.js","sourceRoot":"","sources":["Parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,EACL,qBAAqB,EACrB,GAAG,IAAI,CAAC,EACR,YAAY,EACZ,IAAI,EACJ,4BAA4B,GAC7B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD;;;GAGG;AACH,MAAM,aAAa,GAA4D;IAC7E,IAAI,EAAE,eAAe;IACrB,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE;QAC/E,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QACzD,OAAO,GAAG,CAAyB;YACjC,EAAE,GAAG,EAAE,GAAG,EAAE;oBACV,MAAM,OAAO,GAAG,GAAG,CAA0C;wBAC3D,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,EAAE;wBACnD,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,cAAc,EAAE,SAAS,CAAC,EAAE;wBACtD,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,SAAS,CAAC,EAAE;wBACrD,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,EAAE;qBACjD,CAAC,CAAC;oBACH,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,SAAS,CAAC,CAAC;oBACrD,OAAO,MAAM,CAAC,GAAG,EAAE,CAAC,CAAY;wBAC9B,OAAO,EAAE,cAAc;wBACvB,GAAG,OAAO;wBACV,IAAI,EAAE,OAAO;wBACb,GAAG,CAAC,MAAM,IAAI,EAAE,MAAM,EAAE,CAAC;wBACzB,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAC3B,cAAc,CAAC,EAAE,CAAC,CAAC,CAAC,EACpB,OAAO,EACP,MAAM,CACP;qBACD,CAAA,CAAC,CAAC;gBACN,CAAC,EAAE;YACH,EAAE,GAAG,EAAE,GAAG,EAAE;oBACV,MAAM,OAAO,GAA0B,EAAE,CAAC;oBAC1C,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,cAAc,EAAE,CAAC,CAAC;oBAC1C,IAAI,UAAU,GAAG,IAAI,CAAC;oBACtB,IAAI,CAAC;wBACH,IAAI,EAAE,GAAG,EAAE,CAAC,UAAU;wBACtB,GAAG,EAAE,GAAG,EAAE;4BACR,UAAU,GAAG,KAAK,CAAC;4BACnB,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;4BAE7D,OAAO,CAAC,GAAG,EAAE;gCACX,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;gCAExB,UAAU,GAAG,IAAI,CAAC;gCAClB,MAAM,aAAa,GAAG,QAAQ,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;gCACzD,OAAO,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC;4BAC3C,CAAC,CAAC,CAAC;wBACL,CAAC;qBACF,CAAC,CAAC;oBACH,OAAO,MAAM,CAAC,GAAG,EAAE;wBACjB,MAAM,MAAM,GAAG;4BACb,IAAI,EAAE,QAAQ;4BACd,OAAO;4BACP,GAAG,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAC3B,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,EACrB,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS,EACpB,GAAG,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAE,CAAC,OAAO,EAC1B,OAAO,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAC1B;yBACmB,CAAC;wBACvB,4BAA4B,CAAC,MAAM,CAAC,CAAC;wBACrC,OAAO,MAAM,CAAC;oBAChB,CAAC,CAAC,CAAC;gBACL,CAAC,EAAE;SACJ,CAAC,CAAC;IACL,CAAC;CACF,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,aAAa,CAAC,MAAM,CAAC,sBAAsB,CAAC;KAC9E,KAAK,CAAC,mBAAmB,EAAU,EAAE,CAAC;KACtC,OAAO,CAAC,aAAa,CAAC,CAAC;AAE1B,MAAM,OAAO,MAAO,SAAQ,YAA6B;IACvD;QACE,MAAM,MAAM,GAAG,qBAAqB,CAAC,KAAK,CAAC;YACzC,eAAe,EAAE,CAAC,CAAC,cAAc,CAAC,eAAe;YACjD,iBAAiB,EAAE,qBAAqB;SACzC,CAAC,CAAC;QACH,KAAK,CAAC,MAAM,CAAC,CAAC;IAChB,CAAC;CACF","sourcesContent":["import { ParserBuilder } from '@traqula/core';\nimport type * as T11 from '@traqula/rules-sparql-1-1';\nimport {\n sparqlCodepointEscape,\n lex as l,\n SparqlParser,\n gram,\n updateNoReuseBlankNodeLabels,\n} from '@traqula/rules-sparql-1-1';\nimport { queryUnitParserBuilder } from './queryUnitParser';\nimport { updateParserBuilder } from './updateUnitParser';\n\n/**\n * Query or update, optimized for the Query case.\n * One could implement a new rule that does not use BACKTRACK.\n */\nconst queryOrUpdate: T11.SparqlGrammarRule<'queryOrUpdate', T11.SparqlQuery> = {\n name: 'queryOrUpdate',\n impl: ({ ACTION, SUBRULE, OR1, OR2, MANY, OPTION1, CONSUME, SUBRULE2 }) => (C) => {\n const prologueValues = SUBRULE(gram.prologue, undefined);\n return OR1<T11.Query | T11.Update>([\n { ALT: () => {\n const subType = OR2<Omit<T11.Query, T11.gram.HandledByBase>>([\n { ALT: () => SUBRULE(gram.selectQuery, undefined) },\n { ALT: () => SUBRULE(gram.constructQuery, undefined) },\n { ALT: () => SUBRULE(gram.describeQuery, undefined) },\n { ALT: () => SUBRULE(gram.askQuery, undefined) },\n ]);\n const values = SUBRULE(gram.valuesClause, undefined);\n return ACTION(() => (<T11.Query>{\n context: prologueValues,\n ...subType,\n type: 'query',\n ...(values && { values }),\n loc: C.factory.sourceLocation(\n prologueValues.at(0),\n subType,\n values,\n ),\n }));\n } },\n { ALT: () => {\n const updates: T11.Update['updates'] = [];\n updates.push({ context: prologueValues });\n let parsedSemi = true;\n MANY({\n GATE: () => parsedSemi,\n DEF: () => {\n parsedSemi = false;\n updates.at(-1)!.operation = SUBRULE(gram.update1, undefined);\n\n OPTION1(() => {\n CONSUME(l.symbols.semi);\n\n parsedSemi = true;\n const innerPrologue = SUBRULE2(gram.prologue, undefined);\n updates.push({ context: innerPrologue });\n });\n },\n });\n return ACTION(() => {\n const update = {\n type: 'update',\n updates,\n loc: C.factory.sourceLocation(\n ...updates[0].context,\n updates[0].operation,\n ...updates.at(-1)!.context,\n updates.at(-1)?.operation,\n ),\n } satisfies T11.Update;\n updateNoReuseBlankNodeLabels(update);\n return update;\n });\n } },\n ]);\n },\n};\n\nexport const sparql11ParserBuilder = ParserBuilder.create(queryUnitParserBuilder)\n .merge(updateParserBuilder, <const> [])\n .addRule(queryOrUpdate);\n\nexport class Parser extends SparqlParser<T11.SparqlQuery> {\n public constructor() {\n const parser = sparql11ParserBuilder.build({\n tokenVocabulary: l.sparql11Tokens.tokenVocabulary,\n queryPreProcessor: sparqlCodepointEscape,\n });\n super(parser);\n }\n}\n"]}
package/lib/expressionParser.d.ts ADDED
@@ -0,0 +1,89 @@
1
+ import { ParserBuilder } from '@traqula/core';
2
+ import { gram } from '@traqula/rules-sparql-1-1';
3
+ export declare const expressionParserBuilder: ParserBuilder<import("@traqula/rules-sparql-1-1").SparqlContext, "string" | "var" | "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" | "builtInCount" | "builtInSum" | "builtInMin" | "builtInMax" | "builtInAvg" | "builtInSample" | "builtInGroup_concat" | "expression" | "aggregate" | "rdfLiteral" | "iri" | "numericLiteral" | "numericLiteralUnsigned" | "numericLiteralPositive" | "numericLiteralNegative" | "booleanLiteral" | "prefixedName" | "brackettedExpression" | "builtInCall" | "argList" | "expressionList" | "conditionalOrExpression" | "conditionalAndExpression" | "valueLogical" | "relationalExpression" | "numericExpression" | "additiveExpression" | "multiplicativeExpression" | "unaryExpression" | "primaryExpression" | "iriOrFunction", {
4
+ string: import("@traqula/core").ParserRule<any, "string"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"string", import("@traqula/rules-sparql-1-1").TermLiteralStr>;
5
+ var: import("@traqula/core").ParserRule<any, "var"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"var", import("@traqula/rules-sparql-1-1").TermVariable, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"var", import("@traqula/rules-sparql-1-1").TermVariable, undefined>;
6
+ builtInStr: import("@traqula/core").ParserRule<any, "builtInStr"> & gram.RuleDefExpressionFunctionX<"builtInStr", [import("@traqula/rules-sparql-1-1").Expression]>;
7
+ builtInLang: import("@traqula/core").ParserRule<any, "builtInLang"> & gram.RuleDefExpressionFunctionX<"builtInLang", [import("@traqula/rules-sparql-1-1").Expression]>;
8
+ builtInLangmatches: import("@traqula/core").ParserRule<any, "builtInLangmatches"> & gram.RuleDefExpressionFunctionX<"builtInLangmatches", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
9
+ builtInDatatype: import("@traqula/core").ParserRule<any, "builtInDatatype"> & gram.RuleDefExpressionFunctionX<"builtInDatatype", [import("@traqula/rules-sparql-1-1").Expression]>;
10
+ builtInBound: import("@traqula/core").ParserRule<any, "builtInBound"> & gram.RuleDefExpressionFunctionX<"builtInBound", [import("@traqula/rules-sparql-1-1").TermVariable]>;
11
+ builtInIri: import("@traqula/core").ParserRule<any, "builtInIri"> & gram.RuleDefExpressionFunctionX<"builtInIri", [import("@traqula/rules-sparql-1-1").Expression]>;
12
+ builtInUri: import("@traqula/core").ParserRule<any, "builtInUri"> & gram.RuleDefExpressionFunctionX<"builtInUri", [import("@traqula/rules-sparql-1-1").Expression]>;
13
+ builtInBnode: import("@traqula/core").ParserRule<any, "builtInBnode"> & gram.RuleDefExpressionFunctionX<"builtInBnode", [] | [import("@traqula/rules-sparql-1-1").Expression]>;
14
+ builtInRand: import("@traqula/core").ParserRule<any, "builtInRand"> & gram.RuleDefExpressionFunctionX<"builtInRand", []>;
15
+ builtInAbs: import("@traqula/core").ParserRule<any, "builtInAbs"> & gram.RuleDefExpressionFunctionX<"builtInAbs", [import("@traqula/rules-sparql-1-1").Expression]>;
16
+ builtInCeil: import("@traqula/core").ParserRule<any, "builtInCeil"> & gram.RuleDefExpressionFunctionX<"builtInCeil", [import("@traqula/rules-sparql-1-1").Expression]>;
17
+ builtInFloor: import("@traqula/core").ParserRule<any, "builtInFloor"> & gram.RuleDefExpressionFunctionX<"builtInFloor", [import("@traqula/rules-sparql-1-1").Expression]>;
18
+ builtInRound: import("@traqula/core").ParserRule<any, "builtInRound"> & gram.RuleDefExpressionFunctionX<"builtInRound", [import("@traqula/rules-sparql-1-1").Expression]>;
19
+ builtInConcat: import("@traqula/core").ParserRule<any, "builtInConcat"> & gram.RuleDefExpressionFunctionX<"builtInConcat", import("@traqula/rules-sparql-1-1").Expression[]>;
20
+ builtInStrlen: import("@traqula/core").ParserRule<any, "builtInStrlen"> & gram.RuleDefExpressionFunctionX<"builtInStrlen", [import("@traqula/rules-sparql-1-1").Expression]>;
21
+ builtInUcase: import("@traqula/core").ParserRule<any, "builtInUcase"> & gram.RuleDefExpressionFunctionX<"builtInUcase", [import("@traqula/rules-sparql-1-1").Expression]>;
22
+ builtInLcase: import("@traqula/core").ParserRule<any, "builtInLcase"> & gram.RuleDefExpressionFunctionX<"builtInLcase", [import("@traqula/rules-sparql-1-1").Expression]>;
23
+ builtInEncode_for_uri: import("@traqula/core").ParserRule<any, "builtInEncode_for_uri"> & gram.RuleDefExpressionFunctionX<"builtInEncode_for_uri", [import("@traqula/rules-sparql-1-1").Expression]>;
24
+ builtInContains: import("@traqula/core").ParserRule<any, "builtInContains"> & gram.RuleDefExpressionFunctionX<"builtInContains", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
25
+ builtInStrstarts: import("@traqula/core").ParserRule<any, "builtInStrstarts"> & gram.RuleDefExpressionFunctionX<"builtInStrstarts", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
26
+ builtInStrends: import("@traqula/core").ParserRule<any, "builtInStrends"> & gram.RuleDefExpressionFunctionX<"builtInStrends", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
27
+ builtInStrbefore: import("@traqula/core").ParserRule<any, "builtInStrbefore"> & gram.RuleDefExpressionFunctionX<"builtInStrbefore", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
28
+ builtInStrafter: import("@traqula/core").ParserRule<any, "builtInStrafter"> & gram.RuleDefExpressionFunctionX<"builtInStrafter", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
29
+ builtInYear: import("@traqula/core").ParserRule<any, "builtInYear"> & gram.RuleDefExpressionFunctionX<"builtInYear", [import("@traqula/rules-sparql-1-1").Expression]>;
30
+ builtInMonth: import("@traqula/core").ParserRule<any, "builtInMonth"> & gram.RuleDefExpressionFunctionX<"builtInMonth", [import("@traqula/rules-sparql-1-1").Expression]>;
31
+ builtInDay: import("@traqula/core").ParserRule<any, "builtInDay"> & gram.RuleDefExpressionFunctionX<"builtInDay", [import("@traqula/rules-sparql-1-1").Expression]>;
32
+ builtInHours: import("@traqula/core").ParserRule<any, "builtInHours"> & gram.RuleDefExpressionFunctionX<"builtInHours", [import("@traqula/rules-sparql-1-1").Expression]>;
33
+ builtInMinutes: import("@traqula/core").ParserRule<any, "builtInMinutes"> & gram.RuleDefExpressionFunctionX<"builtInMinutes", [import("@traqula/rules-sparql-1-1").Expression]>;
34
+ builtInSeconds: import("@traqula/core").ParserRule<any, "builtInSeconds"> & gram.RuleDefExpressionFunctionX<"builtInSeconds", [import("@traqula/rules-sparql-1-1").Expression]>;
35
+ builtInTimezone: import("@traqula/core").ParserRule<any, "builtInTimezone"> & gram.RuleDefExpressionFunctionX<"builtInTimezone", [import("@traqula/rules-sparql-1-1").Expression]>;
36
+ builtInTz: import("@traqula/core").ParserRule<any, "builtInTz"> & gram.RuleDefExpressionFunctionX<"builtInTz", [import("@traqula/rules-sparql-1-1").Expression]>;
37
+ builtInNow: import("@traqula/core").ParserRule<any, "builtInNow"> & gram.RuleDefExpressionFunctionX<"builtInNow", []>;
38
+ builtInUuid: import("@traqula/core").ParserRule<any, "builtInUuid"> & gram.RuleDefExpressionFunctionX<"builtInUuid", []>;
39
+ builtInStruuid: import("@traqula/core").ParserRule<any, "builtInStruuid"> & gram.RuleDefExpressionFunctionX<"builtInStruuid", []>;
40
+ builtInMd5: import("@traqula/core").ParserRule<any, "builtInMd5"> & gram.RuleDefExpressionFunctionX<"builtInMd5", [import("@traqula/rules-sparql-1-1").Expression]>;
41
+ builtInSha1: import("@traqula/core").ParserRule<any, "builtInSha1"> & gram.RuleDefExpressionFunctionX<"builtInSha1", [import("@traqula/rules-sparql-1-1").Expression]>;
42
+ builtInSha256: import("@traqula/core").ParserRule<any, "builtInSha256"> & gram.RuleDefExpressionFunctionX<"builtInSha256", [import("@traqula/rules-sparql-1-1").Expression]>;
43
+ builtInSha384: import("@traqula/core").ParserRule<any, "builtInSha384"> & gram.RuleDefExpressionFunctionX<"builtInSha384", [import("@traqula/rules-sparql-1-1").Expression]>;
44
+ builtInSha512: import("@traqula/core").ParserRule<any, "builtInSha512"> & gram.RuleDefExpressionFunctionX<"builtInSha512", [import("@traqula/rules-sparql-1-1").Expression]>;
45
+ builtInCoalesce: import("@traqula/core").ParserRule<any, "builtInCoalesce"> & gram.RuleDefExpressionFunctionX<"builtInCoalesce", import("@traqula/rules-sparql-1-1").Expression[]>;
46
+ builtInIf: import("@traqula/core").ParserRule<any, "builtInIf"> & gram.RuleDefExpressionFunctionX<"builtInIf", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
47
+ builtInStrlang: import("@traqula/core").ParserRule<any, "builtInStrlang"> & gram.RuleDefExpressionFunctionX<"builtInStrlang", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
48
+ builtInStrdt: import("@traqula/core").ParserRule<any, "builtInStrdt"> & gram.RuleDefExpressionFunctionX<"builtInStrdt", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
49
+ builtInSameterm: import("@traqula/core").ParserRule<any, "builtInSameterm"> & gram.RuleDefExpressionFunctionX<"builtInSameterm", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
50
+ builtInIsiri: import("@traqula/core").ParserRule<any, "builtInIsiri"> & gram.RuleDefExpressionFunctionX<"builtInIsiri", [import("@traqula/rules-sparql-1-1").Expression]>;
51
+ builtInIsuri: import("@traqula/core").ParserRule<any, "builtInIsuri"> & gram.RuleDefExpressionFunctionX<"builtInIsuri", [import("@traqula/rules-sparql-1-1").Expression]>;
52
+ builtInIsblank: import("@traqula/core").ParserRule<any, "builtInIsblank"> & gram.RuleDefExpressionFunctionX<"builtInIsblank", [import("@traqula/rules-sparql-1-1").Expression]>;
53
+ builtInIsliteral: import("@traqula/core").ParserRule<any, "builtInIsliteral"> & gram.RuleDefExpressionFunctionX<"builtInIsliteral", [import("@traqula/rules-sparql-1-1").Expression]>;
54
+ builtInIsnumeric: import("@traqula/core").ParserRule<any, "builtInIsnumeric"> & gram.RuleDefExpressionFunctionX<"builtInIsnumeric", [import("@traqula/rules-sparql-1-1").Expression]>;
55
+ builtInRegex: import("@traqula/core").ParserRule<any, "builtInRegex"> & gram.RuleDefExpressionFunctionX<"builtInRegex", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
56
+ builtInSubstr: import("@traqula/core").ParserRule<any, "builtInSubstr"> & gram.RuleDefExpressionFunctionX<"builtInSubstr", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
57
+ builtInReplace: import("@traqula/core").ParserRule<any, "builtInReplace"> & gram.RuleDefExpressionFunctionX<"builtInReplace", [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression] | [import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression, import("@traqula/rules-sparql-1-1").Expression]>;
58
+ builtInCount: import("@traqula/core").ParserRule<any, "builtInCount"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"builtInCount", import("@traqula/rules-sparql-1-1").ExpressionAggregateDefault | import("@traqula/rules-sparql-1-1").ExpressionAggregateOnWildcard>;
59
+ builtInSum: import("@traqula/core").ParserRule<any, "builtInSum"> & gram.RuleDefExpressionAggregatorX<"builtInSum">;
60
+ builtInMin: import("@traqula/core").ParserRule<any, "builtInMin"> & gram.RuleDefExpressionAggregatorX<"builtInMin">;
61
+ builtInMax: import("@traqula/core").ParserRule<any, "builtInMax"> & gram.RuleDefExpressionAggregatorX<"builtInMax">;
62
+ builtInAvg: import("@traqula/core").ParserRule<any, "builtInAvg"> & gram.RuleDefExpressionAggregatorX<"builtInAvg">;
63
+ builtInSample: import("@traqula/core").ParserRule<any, "builtInSample"> & gram.RuleDefExpressionAggregatorX<"builtInSample">;
64
+ builtInGroup_concat: import("@traqula/core").ParserRule<any, "builtInGroup_concat"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"builtInGroup_concat", import("@traqula/rules-sparql-1-1").ExpressionAggregateDefault | import("@traqula/rules-sparql-1-1").ExpressionAggregateSeparator>;
65
+ expression: import("@traqula/core").ParserRule<any, "expression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"expression", import("@traqula/rules-sparql-1-1").Expression, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"expression", import("@traqula/rules-sparql-1-1").Expression, undefined>;
66
+ aggregate: import("@traqula/core").ParserRule<any, "aggregate"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"aggregate", import("@traqula/rules-sparql-1-1").ExpressionAggregate, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"aggregate", import("@traqula/rules-sparql-1-1").ExpressionAggregate, undefined>;
67
+ rdfLiteral: import("@traqula/core").ParserRule<any, "rdfLiteral"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"rdfLiteral", import("@traqula/rules-sparql-1-1").TermLiteral, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"rdfLiteral", import("@traqula/rules-sparql-1-1").TermLiteral, undefined>;
68
+ iri: import("@traqula/core").ParserRule<any, "iri"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"iri", import("@traqula/rules-sparql-1-1").TermIri, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"iri", import("@traqula/rules-sparql-1-1").TermIri, undefined>;
69
+ numericLiteral: import("@traqula/core").ParserRule<any, "numericLiteral"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteral", import("@traqula/rules-sparql-1-1").TermLiteralTyped>;
70
+ numericLiteralUnsigned: import("@traqula/core").ParserRule<any, "numericLiteralUnsigned"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralUnsigned", import("@traqula/rules-sparql-1-1").TermLiteralTyped>;
71
+ numericLiteralPositive: import("@traqula/core").ParserRule<any, "numericLiteralPositive"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralPositive", import("@traqula/rules-sparql-1-1").TermLiteralTyped>;
72
+ numericLiteralNegative: import("@traqula/core").ParserRule<any, "numericLiteralNegative"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericLiteralNegative", import("@traqula/rules-sparql-1-1").TermLiteralTyped>;
73
+ booleanLiteral: import("@traqula/core").ParserRule<any, "booleanLiteral"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"booleanLiteral", import("@traqula/rules-sparql-1-1").TermLiteralTyped>;
74
+ prefixedName: import("@traqula/core").ParserRule<any, "prefixedName"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"prefixedName", import("@traqula/rules-sparql-1-1").TermIriPrefixed, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"prefixedName", import("@traqula/rules-sparql-1-1").TermIriPrefixed, undefined>;
75
+ brackettedExpression: import("@traqula/core").ParserRule<any, "brackettedExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"brackettedExpression", import("@traqula/rules-sparql-1-1").Expression>;
76
+ builtInCall: import("@traqula/core").ParserRule<import("@traqula/rules-sparql-1-1").SparqlContext, "builtInCall", import("@traqula/rules-sparql-1-1").Expression, undefined>;
77
+ argList: import("@traqula/core").ParserRule<any, "argList"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"argList", import("@traqula/core").Wrap<gram.IArgList>, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"argList", import("@traqula/core").Wrap<gram.IArgList>, undefined>;
78
+ expressionList: import("@traqula/core").ParserRule<any, "expressionList"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"expressionList", import("@traqula/core").Wrap<import("@traqula/rules-sparql-1-1").Expression[]>>;
79
+ conditionalOrExpression: import("@traqula/core").ParserRule<any, "conditionalOrExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"conditionalOrExpression", import("@traqula/rules-sparql-1-1").Expression>;
80
+ conditionalAndExpression: import("@traqula/core").ParserRule<any, "conditionalAndExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"conditionalAndExpression", import("@traqula/rules-sparql-1-1").Expression>;
81
+ valueLogical: import("@traqula/core").ParserRule<any, "valueLogical"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"valueLogical", import("@traqula/rules-sparql-1-1").Expression>;
82
+ relationalExpression: import("@traqula/core").ParserRule<any, "relationalExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"relationalExpression", import("@traqula/rules-sparql-1-1").Expression>;
83
+ numericExpression: import("@traqula/core").ParserRule<any, "numericExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"numericExpression", import("@traqula/rules-sparql-1-1").Expression>;
84
+ additiveExpression: import("@traqula/core").ParserRule<any, "additiveExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"additiveExpression", import("@traqula/rules-sparql-1-1").Expression>;
85
+ multiplicativeExpression: import("@traqula/core").ParserRule<any, "multiplicativeExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"multiplicativeExpression", import("@traqula/rules-sparql-1-1").Expression>;
86
+ unaryExpression: import("@traqula/core").ParserRule<any, "unaryExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"unaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
87
+ primaryExpression: import("@traqula/core").ParserRule<any, "primaryExpression"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"primaryExpression", import("@traqula/rules-sparql-1-1").Expression>;
88
+ iriOrFunction: import("@traqula/core").ParserRule<any, "iriOrFunction"> & import("@traqula/rules-sparql-1-1").SparqlGrammarRule<"iriOrFunction", import("@traqula/rules-sparql-1-1").ExpressionFunctionCall | import("@traqula/rules-sparql-1-1").TermIri, undefined> & import("@traqula/rules-sparql-1-1").SparqlGeneratorRule<"iriOrFunction", import("@traqula/rules-sparql-1-1").ExpressionFunctionCall | import("@traqula/rules-sparql-1-1").TermIri, undefined>;
89
+ }>;