@traqula/rules-sparql-1-2 0.0.1-alpha.176 → 0.0.1-alpha.9

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

@@ -4,134 +4,116 @@
  * 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 } from '@traqula/core';
+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 { BaseQuadTerm, Expression, IGraphNode, Term, Triple } from './sparql12Types';
+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';
 /**
- * [[56]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlock) Used by triplesSameSubject
+ *[[7]](https://www.w3.org/TR/sparql12-query/#rVersionDecl)
  */
-export declare const reifiedTripleBlock: T11.SparqlGrammarRule<"reifiedTripleBlock", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], undefined>;
+export declare const versionDecl: SparqlRule<'versionDecl', ContextDefinitionVersion>;
 /**
- * [[57]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleBlockPath) Used by TriplesSameSubjectPath
+ * [[8]](https://www.w3.org/TR/sparql12-query/#rVersionSpecifier)
  */
-export declare const reifiedTripleBlockPath: T11.SparqlGrammarRule<"reifiedTripleBlockPath", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], undefined>;
+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}.
- * [[67]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
+ * [[69]](https://www.w3.org/TR/sparql12-query/#rDataBlockValue)
  */
-export declare const dataBlockValue: T11.SparqlRule<'dataBlockValue', RuleDefReturn<typeof S11.dataBlockValue> | BaseQuadTerm>;
+export declare const dataBlockValue: T11.SparqlGrammarRule<'dataBlockValue', RuleDefReturn<typeof S11.dataBlockValue> | TermTriple>;
 /**
- * [[68]](https://www.w3.org/TR/sparql12-query/#rReifier)
+ * [[70]](https://www.w3.org/TR/sparql12-query/#rReifier)
  */
-export declare const reifier: T11.SparqlGrammarRule<'reifier', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
+export declare const reifier: T11.SparqlGrammarRule<'reifier', RuleDefReturn<typeof varOrReifierId>>;
 /**
- * [[68]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
+ * [[71]](https://www.w3.org/TR/sparql12-query/#rVarOrReifierId)
  */
-export declare const varOrReifierId: T11.SparqlGrammarRule<'varOrReifierId', T11.VariableTerm | T11.IriTerm | T11.BlankTerm>;
+export declare const varOrReifierId: T11.SparqlGrammarRule<'varOrReifierId', TermVariable | TermIri | TermBlank>;
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubject}
- * [[79]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
+ * [[81]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubject)
  */
-export declare const triplesSameSubject: T11.SparqlGrammarRule<"triplesSameSubject", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], undefined>;
+export declare const triplesSameSubject: T11.SparqlGrammarRule<"triplesSameSubject", T11.BasicGraphPattern, undefined>;
 /**
  * OVERRIDING RULE {@link S11.triplesSameSubjectPath}
- * [[85]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
+ * [[87]](https://www.w3.org/TR/sparql12-query/#rTriplesSameSubjectPath)
  */
-export declare const triplesSameSubjectPath: T11.SparqlGrammarRule<"triplesSameSubjectPath", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], undefined>;
+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: T11.SparqlGrammarRule<"object", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], Pick<import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>, "subject" | "predicate">>;
+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: T11.SparqlGrammarRule<"objectPath", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], Pick<import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>, "subject" | "predicate">>;
+export declare const objectPath: SparqlGrammarRule<"objectPath", TripleNesting, Pick<TripleNesting, "subject" | "predicate">>;
 /**
  * [[107]](https://www.w3.org/TR/sparql12-query/#rAnnotationPath)
  */
-export declare const annotationPath: T11.SparqlGrammarRule<"annotationPath", import("@traqula/core").Patch<T11.IGraphNode, {
-    triples: Triple[];
-    node: import("./sparql12Types").ITriplesNode["node"] | Term;
-}>[], undefined>;
+export declare const annotationPath: SparqlRule<"annotationPath", Annotation[]>;
 /**
- * [[109]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
+ * [[111]](https://www.w3.org/TR/sparql12-query/#rAnnotation)
  */
-export declare const annotation: T11.SparqlGrammarRule<"annotation", import("@traqula/core").Patch<T11.IGraphNode, {
-    triples: Triple[];
-    node: import("./sparql12Types").ITriplesNode["node"] | Term;
-}>[], undefined>;
+export declare const annotation: SparqlRule<"annotation", Annotation[]>;
 /**
- * [[108]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
+ * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlockPath)
  */
-export declare const annotationBlockPath: T11.SparqlGrammarRule<"annotationBlockPath", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], Pick<import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>, "subject">>;
+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;
+}>>;
 /**
- * [[110]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
+ * [[112]](https://www.w3.org/TR/sparql12-query/#rAnnotationBlock)
  */
-export declare const annotationBlock: T11.SparqlGrammarRule<"annotationBlock", import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>[], Pick<import("@traqula/core").Patch<T11.Triple, {
-    subject: Term;
-    object: Term;
-}>, "subject">>;
+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: T11.SparqlGrammarRule<'graphNode', IGraphNode>;
+export declare const graphNode: SparqlGrammarRule<'graphNode', GraphNode>;
 /**
  * OVERRIDING RULE: {@link S11.graphNodePath}.
- * [[112]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
+ * [[114]](https://www.w3.org/TR/sparql12-query/#rGraphNodePath)
  */
-export declare const graphNodePath: T11.SparqlGrammarRule<'graphNodePath', IGraphNode>;
+export declare const graphNodePath: SparqlRule<'graphNodePath', GraphNode>;
 /**
  * OVERRIDING RULE: {@link S11.varOrTerm}.
- * [[113]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
+ * [[115]](https://www.w3.org/TR/sparql12-query/#rVarOrTerm)
  */
-export declare const varOrTerm: T11.SparqlRule<'varOrTerm', Term>;
+export declare const varOrTerm: SparqlGrammarRule<'varOrTerm', Term>;
 /**
  * [[114]](https://www.w3.org/TR/sparql12-query/#rReifiedTriple)
  */
-export declare const reifiedTriple: T11.SparqlGrammarRule<'reifiedTriple', IGraphNode & {
-    node: T11.BlankTerm | T11.VariableTerm | T11.IriTerm;
-}>;
+export declare const reifiedTriple: SparqlRule<'reifiedTriple', TripleCollectionReifiedTriple>;
 /**
  * [[115]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleSubject)
  */
-export declare const reifiedTripleSubject: T11.SparqlGrammarRule<'reifiedTripleSubject', IGraphNode>;
+export declare const reifiedTripleSubject: T11.SparqlGrammarRule<'reifiedTripleSubject', Term | TripleCollectionReifiedTriple>;
 /**
  * [[116]](https://www.w3.org/TR/sparql12-query/#rReifiedTripleObject)
  */
@@ -139,44 +121,44 @@ export declare const reifiedTripleObject: T11.SparqlGrammarRule<'reifiedTripleOb
 /**
  * [[117]](https://www.w3.org/TR/sparql12-query/#rTripleTerm)
  */
-export declare const tripleTerm: T11.SparqlRule<'tripleTerm', BaseQuadTerm>;
+export declare const tripleTerm: SparqlRule<'tripleTerm', TermTriple>;
 /**
- * [[118]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
+ * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermSubject)
  */
-export declare const tripleTermSubject: T11.SparqlGrammarRule<'tripleTermSubject', T11.VariableTerm | T11.IriTerm | T11.LiteralTerm | T11.BlankTerm>;
+export declare const tripleTermSubject: T11.SparqlGrammarRule<'tripleTermSubject', TermVariable | TermIri | TermLiteral | TermBlank | TermTriple>;
 /**
- * [[119]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
+ * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermObject)
  */
-export declare const tripleTermObject: T11.SparqlGrammarRule<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject> | BaseQuadTerm>;
+export declare const tripleTermObject: T11.SparqlGrammarRule<'tripleTermObject', RuleDefReturn<typeof tripleTermSubject>>;
 /**
- * [[120]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
+ * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermData)
  */
-export declare const tripleTermData: T11.SparqlGrammarRule<'tripleTermData', BaseQuadTerm>;
+export declare const tripleTermData: SparqlGrammarRule<'tripleTermData', TermTriple>;
 /**
- * [[121]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
+ * [[123]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataSubject)
  */
-export declare const tripleTermDataSubject: T11.SparqlGrammarRule<'tripleTermDataSubject', T11.IriTerm | T11.LiteralTerm>;
+export declare const tripleTermDataSubject: T11.SparqlGrammarRule<'tripleTermDataSubject', TermIri | TermLiteral | TermTriple>;
 /**
- * [[122]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
+ * [[124]](https://www.w3.org/TR/sparql12-query/#rTripleTermDataObject)
  */
-export declare const tripleTermDataObject: T11.SparqlGrammarRule<'tripleTermDataObject', RuleDefReturn<typeof tripleTermDataSubject> | BaseQuadTerm>;
+export declare const tripleTermDataObject: T11.SparqlGrammarRule<'tripleTermDataObject', RuleDefReturn<typeof tripleTermDataSubject>>;
 /**
  * OVERRIDING RULE: {@link S11.primaryExpression}.
- * [[134]](https://www.w3.org/TR/sparql12-query/#rPrimaryExpression)
+ * [[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: T11.SparqlGrammarRule<'exprTripleTerm', BaseQuadTerm>;
+export declare const exprTripleTerm: SparqlGrammarRule<'exprTripleTerm', TermTriple>;
 /**
- * [[136]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
+ * [[138]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermSubject)
  */
-export declare const exprTripleTermSubject: T11.SparqlGrammarRule<'exprTripleTermSubject', T11.IriTerm | T11.VariableTerm | T11.LiteralTerm>;
+export declare const exprTripleTermSubject: T11.SparqlGrammarRule<'exprTripleTermSubject', TermIri | TermVariable | TermLiteral | TermTriple>;
 /**
- * [[137]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
+ * [[139]](https://www.w3.org/TR/sparql12-query/#rExprTripleTermObject)
  */
-export declare const exprTripleTermObject: T11.SparqlGrammarRule<'exprTripleTermObject', RuleDefReturn<typeof exprTripleTermSubject> | BaseQuadTerm>;
+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]>;
@@ -188,12 +170,22 @@ export declare const builtinPredicate: S11.RuleDefExpressionFunctionX<"builtInPr
 export declare const builtinObject: S11.RuleDefExpressionFunctionX<"builtInObject", [T11.Expression]>;
 /**
  * OVERRIDING RULE: {@link S11.builtInCall}.
- * [[139]](https://www.w3.org/TR/sparql12-query/#rBuiltInCall)
+ * [[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
- * [[147]](https://www.w3.org/TR/sparql12-query/#rRDFLiteral)
+ * [[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 rdfLiteral: T11.SparqlGrammarRule<'rdfLiteral', T11.LiteralTerm>;
+export declare const generateGraphTerm: SparqlGeneratorRule<'graphTerm', GraphTerm>;