@traqula/rules-sparql-1-2 0.0.1-alpha.10

package/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright © 2024–now Jitse De Smet
+Comunica Association and Ghent University – imec, Belgium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# Traqula Rules SPARQL 1.2 package
+
+**WARNING:** V2 will come shortly and will have lots of breaking changes.
+
+Traqula rules SPARQL 1.2 contains additional rules required for creating a parser for SPARQL 1.2 from the SPARQL 1.1 rules.
+
+## Installation
+
+```bash
+npm install @traqula/rules-sparql-1-2
+```
+
+or
+
+```bash
+yarn add @traqula/rules-sparql-1-2
+```

package/lib/Factory.d.ts

@@ -0,0 +1,18 @@
+import type { SourceLocation, SubTyped } from '@traqula/core';
+import { Factory as Sparql11Factory } from '@traqula/rules-sparql-1-1';
+import type * as T11 from '@traqula/rules-sparql-1-1';
+import type { Annotation, ContextDefinitionVersion, TermBlank, TermIri, TermTriple, TermVariable, TripleCollectionReifiedTriple, TripleNesting } from './sparql12Types';
+export declare class Factory extends Sparql11Factory {
+    termTriple(subject: TermTriple['subject'], predicate: TermTriple['predicate'], object: TermTriple['object'], loc: SourceLocation): TermTriple;
+    isTermTriple(obj: object): obj is SubTyped<'term', 'triple'>;
+    tripleCollectionReifiedTriple(loc: SourceLocation, subject: TripleNesting['subject'], predicate: TripleNesting['predicate'], object: TripleNesting['object'], reifier?: TripleCollectionReifiedTriple['identifier']): TripleCollectionReifiedTriple;
+    isTripleCollectionReifiedTriple(obj: object): obj is SubTyped<'tripleCollection', 'reifiedTriple'>;
+    tripleCollectionBlankNodeProperties(identifier: TermBlank | TermVariable | TermIri, triples: TripleNesting[], loc: SourceLocation): T11.TripleCollectionBlankNodeProperties;
+    /**
+     * Overwritten triple constructor to always contain an empty annotations list
+     */
+    triple: Sparql11Factory['triple'];
+    annotatedTriple(subject: TripleNesting['subject'], predicate: TripleNesting['predicate'], object: TripleNesting['object'], annotations?: Annotation[], loc?: SourceLocation): TripleNesting;
+    contextDefinitionVersion(version: string, loc: SourceLocation): ContextDefinitionVersion;
+    isContextDefinitionVersion(obj: object): obj is SubTyped<'contextDef', 'version'>;
+}

package/lib/Factory.js

@@ -0,0 +1,73 @@
+import { Factory as Sparql11Factory } from '@traqula/rules-sparql-1-1';
+export class Factory extends Sparql11Factory {
+    constructor() {
+        super(...arguments);
+        /**
+         * Overwritten triple constructor to always contain an empty annotations list
+         */
+        this.triple = (subject, predicate, object, loc) => ({
+            type: 'triple',
+            subject,
+            predicate,
+            object,
+            annotations: [],
+            loc: loc ?? this.sourceLocation(subject, predicate, object),
+        });
+    }
+    termTriple(subject, predicate, object, loc) {
+        return {
+            type: 'term',
+            subType: 'triple',
+            subject,
+            predicate,
+            object,
+            loc,
+        };
+    }
+    isTermTriple(obj) {
+        return this.isOfSubType(obj, 'term', 'triple');
+    }
+    tripleCollectionReifiedTriple(loc, subject, predicate, object, reifier) {
+        return {
+            type: 'tripleCollection',
+            subType: 'reifiedTriple',
+            triples: [this.triple(subject, predicate, object)],
+            identifier: reifier ?? this.blankNode(undefined, this.sourceLocationNoMaterialize()),
+            loc,
+        };
+    }
+    isTripleCollectionReifiedTriple(obj) {
+        return this.isOfSubType(obj, 'tripleCollection', 'reifiedTriple');
+    }
+    tripleCollectionBlankNodeProperties(identifier, triples, loc) {
+        return {
+            type: 'tripleCollection',
+            subType: 'blankNodeProperties',
+            triples,
+            identifier,
+            loc,
+        };
+    }
+    annotatedTriple(subject, predicate, object, annotations, loc) {
+        return {
+            type: 'triple',
+            subject,
+            predicate,
+            object,
+            annotations: annotations ?? [],
+            loc: loc ?? this.sourceLocation(subject, predicate, object, ...annotations ?? []),
+        };
+    }
+    contextDefinitionVersion(version, loc) {
+        return {
+            type: 'contextDef',
+            subType: 'version',
+            version,
+            loc,
+        };
+    }
+    isContextDefinitionVersion(obj) {
+        return this.isOfSubType(obj, 'contextDef', 'version');
+    }
+}
+//# sourceMappingURL=Factory.js.map

package/lib/Factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Factory.js","sourceRoot":"","sources":["Factory.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,IAAI,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAcvE,MAAM,OAAO,OAAQ,SAAQ,eAAe;IAA5C;;QAuDE;;WAEG;QACa,WAAM,GACpB,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,CAAC,CAAoB;YACvD,IAAI,EAAE,QAAQ;YACd,OAAO;YACP,SAAS;YACT,MAAM;YACN,WAAW,EAAE,EAAE;YACf,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,CAAC;SACpC,CAAA,CAAC;IA+B9B,CAAC;IAhGQ,UAAU,CACf,OAA8B,EAC9B,SAAkC,EAClC,MAA4B,EAC5B,GAAmB;QAEnB,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,OAAO,EAAE,QAAQ;YACjB,OAAO;YACP,SAAS;YACT,MAAM;YACN,GAAG;SACJ,CAAC;IACJ,CAAC;IAEM,YAAY,CAAC,GAAW;QAC7B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;IAEM,6BAA6B,CAClC,GAAmB,EACnB,OAAiC,EACjC,SAAqC,EACrC,MAA+B,EAC/B,OAAqD;QAErD,OAAO;YACL,IAAI,EAAE,kBAAkB;YACxB,OAAO,EAAE,eAAe;YACxB,OAAO,EAAE,CAAE,IAAI,CAAC,MAAM,CAA+B,OAAO,EAAE,SAAS,EAA+B,MAAM,CAAC,CAAE;YAC/G,UAAU,EAAE,OAAO,IAAI,IAAI,CAAC,SAAS,CAAC,SAAS,EAAE,IAAI,CAAC,2BAA2B,EAAE,CAAC;YACpF,GAAG;SACJ,CAAC;IACJ,CAAC;IAEM,+BAA+B,CAAC,GAAW;QAChD,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,kBAAkB,EAAE,eAAe,CAAC,CAAC;IACpE,CAAC;IAEe,mCAAmC,CACjD,UAA8C,EAC9C,OAAwB,EACxB,GAAmB;QAEnB,OAAiD;YAC/C,IAAI,EAAE,kBAAkB;YACxB,OAAO,EAAE,qBAAqB;YAC9B,OAAO;YACP,UAAU;YACV,GAAG;SAC0C,CAAC;IAClD,CAAC;IAeM,eAAe,CACpB,OAAiC,EACjC,SAAqC,EACrC,MAA+B,EAC/B,WAA0B,EAC1B,GAAoB;QAEpB,OAAO;YACL,IAAI,EAAE,QAAQ;YACd,OAAO;YACP,SAAS;YACT,MAAM;YACN,WAAW,EAAE,WAAW,IAAI,EAAE;YAC9B,GAAG,EAAE,GAAG,IAAI,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,WAAW,IAAI,EAAE,CAAC;SAClF,CAAC;IACJ,CAAC;IAEM,wBAAwB,CAAC,OAAe,EAAE,GAAmB;QAClE,OAAO;YACL,IAAI,EAAE,YAAY;YAClB,OAAO,EAAE,SAAS;YAClB,OAAO;YACP,GAAG;SACJ,CAAC;IACJ,CAAC;IAEM,0BAA0B,CAAC,GAAW;QAC3C,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,YAAY,EAAE,SAAS,CAAC,CAAC;IACxD,CAAC;CACF","sourcesContent":["import type { SourceLocation, SubTyped } from '@traqula/core';\nimport { Factory as Sparql11Factory } from '@traqula/rules-sparql-1-1';\nimport type * as T11 from '@traqula/rules-sparql-1-1';\nimport type {\n  Annotation,\n  ContextDefinitionVersion,\n  TermBlank,\n  TermIri,\n  TermTriple,\n  TermVariable,\n  TripleCollectionBlankNodeProperties,\n  TripleCollectionReifiedTriple,\n  TripleNesting,\n} from './sparql12Types';\n\nexport class Factory extends Sparql11Factory {\n  public termTriple(\n    subject: TermTriple['subject'],\n    predicate: TermTriple['predicate'],\n    object: TermTriple['object'],\n    loc: SourceLocation,\n  ): TermTriple {\n    return {\n      type: 'term',\n      subType: 'triple',\n      subject,\n      predicate,\n      object,\n      loc,\n    };\n  }\n\n  public isTermTriple(obj: object): obj is SubTyped<'term', 'triple'> {\n    return this.isOfSubType(obj, 'term', 'triple');\n  }\n\n  public tripleCollectionReifiedTriple(\n    loc: SourceLocation,\n    subject: TripleNesting['subject'],\n    predicate: TripleNesting['predicate'],\n    object: TripleNesting['object'],\n    reifier?: TripleCollectionReifiedTriple['identifier'],\n  ): TripleCollectionReifiedTriple {\n    return {\n      type: 'tripleCollection',\n      subType: 'reifiedTriple',\n      triples: [ this.triple(<T11.TripleNesting['subject']>subject, predicate, <T11.TripleNesting['object']>object) ],\n      identifier: reifier ?? this.blankNode(undefined, this.sourceLocationNoMaterialize()),\n      loc,\n    };\n  }\n\n  public isTripleCollectionReifiedTriple(obj: object): obj is SubTyped<'tripleCollection', 'reifiedTriple'> {\n    return this.isOfSubType(obj, 'tripleCollection', 'reifiedTriple');\n  }\n\n  public override tripleCollectionBlankNodeProperties(\n    identifier: TermBlank | TermVariable | TermIri,\n    triples: TripleNesting[],\n    loc: SourceLocation,\n  ): T11.TripleCollectionBlankNodeProperties {\n    return <T11.TripleCollectionBlankNodeProperties> {\n      type: 'tripleCollection',\n      subType: 'blankNodeProperties',\n      triples,\n      identifier,\n      loc,\n    } satisfies TripleCollectionBlankNodeProperties;\n  }\n\n  /**\n   * Overwritten triple constructor to always contain an empty annotations list\n   */\n  public override triple: Sparql11Factory['triple'] =\n    (subject, predicate, object, loc) => <T11.TripleNesting> {\n      type: 'triple',\n      subject,\n      predicate,\n      object,\n      annotations: [],\n      loc: loc ?? this.sourceLocation(subject, predicate, object),\n    } satisfies TripleNesting;\n\n  public annotatedTriple(\n    subject: TripleNesting['subject'],\n    predicate: TripleNesting['predicate'],\n    object: TripleNesting['object'],\n    annotations?: Annotation[],\n    loc?: SourceLocation,\n  ): TripleNesting {\n    return {\n      type: 'triple',\n      subject,\n      predicate,\n      object,\n      annotations: annotations ?? [],\n      loc: loc ?? this.sourceLocation(subject, predicate, object, ...annotations ?? []),\n    };\n  }\n\n  public contextDefinitionVersion(version: string, loc: SourceLocation): ContextDefinitionVersion {\n    return {\n      type: 'contextDef',\n      subType: 'version',\n      version,\n      loc,\n    };\n  }\n\n  public isContextDefinitionVersion(obj: object): obj is SubTyped<'contextDef', 'version'> {\n    return this.isOfSubType(obj, 'contextDef', 'version');\n  }\n}\n"]}

package/lib/grammar.d.ts

@@ -0,0 +1,191 @@
+/**
+ * This module will define patch rules that should be used in combination with the sparql11 grammar to create
+ * a sparql12 grammar.
+ * Rules in this module redefine the return type of core grammar rules.
+ * It is therefore essential that the parser retypes the rules from the core grammar.
+ */
+import type { RuleDefReturn, Wrap } from '@traqula/core';
+import { gram as S11 } from '@traqula/rules-sparql-1-1';
+import type * as T11 from '@traqula/rules-sparql-1-1';
+import type { SparqlGeneratorRule, SparqlGrammarRule, SparqlRule } from './sparql12HelperTypes';
+import type { Annotation, ContextDefinition, ContextDefinitionVersion, Expression, GraphNode, GraphTerm, PatternBgp, Term, TermBlank, TermIri, TermLiteral, TermTriple, TermVariable, TripleCollectionReifiedTriple, TripleNesting } from './sparql12Types';
+/**
+ *[[7]](https://www.w3.org/TR/sparql12-query/#rVersionDecl)
+ */
+export declare const versionDecl: SparqlRule<'versionDecl', ContextDefinitionVersion>;
+/**
+ * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
+ */
+export declare const versionSpecifier: SparqlGrammarRule<'versionSpecifier', Wrap<string>>;
+/**
+ * OVERRIDING RULE {@link S11.prologue}
+ * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
+ */
+export declare const prologue: SparqlRule<'prologue', ContextDefinition[]>;
+/**
+ * [[58]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
+ */
+export declare const reifiedTripleBlock: T11.SparqlGrammarRule<"reifiedTripleBlock", T11.BasicGraphPattern, undefined>;
+/**
+ * [[59]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
+ */
+export declare const reifiedTripleBlockPath: T11.SparqlGrammarRule<"reifiedTripleBlockPath", T11.BasicGraphPattern, undefined>;
+/**
+ * OVERRIDING RULE: {@link S11.dataBlockValue}.
+ * [[69]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
+ */
+export declare const dataBlockValue: T11.SparqlGrammarRule<'dataBlockValue', RuleDefReturn<typeof S11.dataBlockValue> | TermTriple>;
+/**
+ * [[70]](https://www.w3.org/TR/sparql12-query/#rReifier)
+ */
+export declare const reifier: T11.SparqlGrammarRule<'reifier', RuleDefReturn<typeof varOrReifierId>>;
+/**
+ * [[71]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
+ */
+export declare const varOrReifierId: T11.SparqlGrammarRule<'varOrReifierId', TermVariable | TermIri | TermBlank>;
+/**
+ * OVERRIDING RULE {@link S11.triplesSameSubject}
+ * [[81]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
+ */
+export declare const triplesSameSubject: T11.SparqlGrammarRule<"triplesSameSubject", T11.BasicGraphPattern, undefined>;
+/**
+ * OVERRIDING RULE {@link S11.triplesSameSubjectPath}
+ * [[87]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
+ */
+export declare const triplesSameSubjectPath: T11.SparqlGrammarRule<"triplesSameSubjectPath", T11.BasicGraphPattern, undefined>;
+/**
+ * OVERRIDING RULE: {@link S11.object}.
+ * [[84]](https://www.w3.org/TR/sparql12-query/#rObject) Used by ObjectList
+ */
+export declare const object: SparqlGrammarRule<"object", TripleNesting, Pick<TripleNesting, "subject" | "predicate">>;
+/**
+ * OVERRIDING RULE: {@link S11.objectPath}.
+ * [[91]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath) Used by ObjectListPath
+ */
+export declare const objectPath: SparqlGrammarRule<"objectPath", TripleNesting, Pick<TripleNesting, "subject" | "predicate">>;
+/**
+ * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
+ */
+export declare const annotationPath: SparqlRule<"annotationPath", Annotation[]>;
+/**
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
+ */
+export declare const annotation: SparqlRule<"annotation", Annotation[]>;
+/**
+ * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
+ */
+export declare const annotationBlockPath: SparqlGrammarRule<"annotationBlockPath", import("@traqula/core").Patch<T11.TripleCollectionBlankNodeProperties, {
+    triples: TripleNesting[];
+    identifier: TermBlank | TermVariable | TermIri;
+}>, T11.TermIri | T11.TermVariable | T11.TermBlank> & SparqlGeneratorRule<"annotationBlockPath", import("@traqula/core").Patch<T11.TripleCollectionBlankNodeProperties, {
+    triples: TripleNesting[];
+    identifier: TermBlank | TermVariable | TermIri;
+}>>;
+/**
+ * [[112]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
+ */
+export declare const annotationBlock: SparqlGrammarRule<"annotationBlock", import("@traqula/core").Patch<T11.TripleCollectionBlankNodeProperties, {
+    triples: TripleNesting[];
+    identifier: TermBlank | TermVariable | TermIri;
+}>, T11.TermIri | T11.TermVariable | T11.TermBlank> & SparqlGeneratorRule<"annotationBlock", import("@traqula/core").Patch<T11.TripleCollectionBlankNodeProperties, {
+    triples: TripleNesting[];
+    identifier: TermBlank | TermVariable | TermIri;
+}>>;
+/**
+ * OVERRIDING RULE: {@link S11.graphNode}.
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rGraphNode)
+ */
+export declare const graphNode: SparqlGrammarRule<'graphNode', GraphNode>;
+/**
+ * OVERRIDING RULE: {@link S11.graphNodePath}.
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
+ */
+export declare const graphNodePath: SparqlRule<'graphNodePath', GraphNode>;
+/**
+ * OVERRIDING RULE: {@link S11.varOrTerm}.
+ * [[115]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
+ */
+export declare const varOrTerm: SparqlGrammarRule<'varOrTerm', Term>;
+/**
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
+ */
+export declare const reifiedTriple: SparqlRule<'reifiedTriple', TripleCollectionReifiedTriple>;
+/**
+ * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
+ */
+export declare const reifiedTripleSubject: T11.SparqlGrammarRule<'reifiedTripleSubject', Term | TripleCollectionReifiedTriple>;
+/**
+ * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
+ */
+export declare const reifiedTripleObject: T11.SparqlGrammarRule<'reifiedTripleObject', RuleDefReturn<typeof reifiedTripleSubject>>;
+/**
+ * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
+ */
+export declare const tripleTerm: SparqlRule<'tripleTerm', TermTriple>;
+/**
+ * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
+ */
+export declare const tripleTermSubject: T11.SparqlGrammarRule<'tripleTermSubject', TermVariable | TermIri | TermLiteral | TermBlank | TermTriple>;
+/**
+ * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
+ */
+export declare const tripleTermObject: T11.SparqlGrammarRule<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject>>;
+/**
+ * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
+ */
+export declare const tripleTermData: SparqlGrammarRule<'tripleTermData', TermTriple>;
+/**
+ * [[123]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
+ */
+export declare const tripleTermDataSubject: T11.SparqlGrammarRule<'tripleTermDataSubject', TermIri | TermLiteral | TermTriple>;
+/**
+ * [[124]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
+ */
+export declare const tripleTermDataObject: T11.SparqlGrammarRule<'tripleTermDataObject', RuleDefReturn<typeof tripleTermDataSubject>>;
+/**
+ * OVERRIDING RULE: {@link S11.primaryExpression}.
+ * [[136]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
+ */
+export declare const primaryExpression: T11.SparqlGrammarRule<'primaryExpression', Expression>;
+/**
+ * [[135]](https://www.w3.org/TR/sparql12-query/#rExprTripleTerm)
+ */
+export declare const exprTripleTerm: SparqlGrammarRule<'exprTripleTerm', TermTriple>;
+/**
+ * [[138]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
+ */
+export declare const exprTripleTermSubject: T11.SparqlGrammarRule<'exprTripleTermSubject', TermIri | TermVariable | TermLiteral | TermTriple>;
+/**
+ * [[139]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
+ */
+export declare const exprTripleTermObject: T11.SparqlGrammarRule<'exprTripleTermObject', RuleDefReturn<typeof exprTripleTermSubject> | TermTriple>;
+export declare const builtinLangDir: S11.RuleDefExpressionFunctionX<"builtInLangdir", [T11.Expression]>;
+export declare const builtinLangStrDir: S11.RuleDefExpressionFunctionX<"builtInStrLangdir", [T11.Expression, T11.Expression, T11.Expression]>;
+export declare const builtinHasLang: S11.RuleDefExpressionFunctionX<"builtInHasLang", [T11.Expression]>;
+export declare const builtinHasLangDir: S11.RuleDefExpressionFunctionX<"builtInHasLangdir", [T11.Expression]>;
+export declare const builtinIsTriple: S11.RuleDefExpressionFunctionX<"builtInIsTriple", [T11.Expression]>;
+export declare const builtinTriple: S11.RuleDefExpressionFunctionX<"builtInTriple", [T11.Expression, T11.Expression, T11.Expression]>;
+export declare const builtinSubject: S11.RuleDefExpressionFunctionX<"builtInSubject", [T11.Expression]>;
+export declare const builtinPredicate: S11.RuleDefExpressionFunctionX<"builtInPredicate", [T11.Expression]>;
+export declare const builtinObject: S11.RuleDefExpressionFunctionX<"builtInObject", [T11.Expression]>;
+/**
+ * OVERRIDING RULE: {@link S11.builtInCall}.
+ * [[141]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
+ */
+export declare const builtInCall: typeof S11.builtInCall;
+/**
+ * OVERRIDING RULE: {@link S11.rdfLiteral}.
+ * No retyping is needed since the return type is the same
+ * [[149]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
+ */
+export declare const rdfLiteral: SparqlGrammarRule<'rdfLiteral', RuleDefReturn<typeof S11.rdfLiteral>>;
+/**
+ * OVERRIDING RULE: {@link S11.triplesBlock}.
+ */
+export declare const generateTriplesBlock: SparqlGeneratorRule<'triplesBlock', PatternBgp>;
+/**
+ * OVERRIDING RULE: {@link S11.graphTerm}.
+ * No retyping is needed since the return type is the same
+ * [[149]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
+ */
+export declare const generateGraphTerm: SparqlGeneratorRule<'graphTerm', GraphTerm>;