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

package/lib/factory.d.ts

@@ -0,0 +1,447 @@
+import type { SourceLocation, SubTyped, Typed } from '@traqula/core';
+import { CoreFactory } from '@traqula/core';
+import type { DatasetClauses, GraphNode, GraphQuads, PatternBgp, Sparql11Nodes, Term, TermBlank, TermIri, TermVariable, TripleCollectionBlankNodeProperties, TripleCollectionList, TripleNesting, Update, Wildcard } from './RoundTripTypes';
+declare const Factory_base: {
+    new (...args: any[]): {
+        isUpdateOperation(obj: object): obj is Typed<"updateOperation">;
+        updateOperationLoad(loc: SourceLocation, source: TermIri, silent: boolean, destination?: import("./RoundTripTypes").GraphRefSpecific | undefined): import("./RoundTripTypes").UpdateOperationLoad;
+        isUpdateOperationLoad(obj: object): obj is SubTyped<"updateOperation", "load">;
+        updateOperationClearDrop(subType: "clear", silent: boolean, destination: import("./RoundTripTypes").GraphRef, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationClear;
+        updateOperationClearDrop(subType: "drop", silent: boolean, destination: import("./RoundTripTypes").GraphRef, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDrop;
+        updateOperationClearDrop(subType: "clear" | "drop", silent: boolean, destination: import("./RoundTripTypes").GraphRef, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationClear | import("./RoundTripTypes").UpdateOperationDrop;
+        updateOperationClear(destination: import("./RoundTripTypes").GraphRef, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationClear;
+        isUpdateOperationClear(obj: object): obj is SubTyped<"updateOperation", "clear">;
+        updateOperationDrop(destination: import("./RoundTripTypes").GraphRef, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDrop;
+        isUpdateOperationDrop(obj: object): obj is SubTyped<"updateOperation", "drop">;
+        updateOperationCreate(destination: import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationCreate;
+        isUpdateOperationCreate(obj: object): obj is SubTyped<"updateOperation", "create">;
+        updateOperationAddMoveCopy(subType: "add", source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationAdd;
+        updateOperationAddMoveCopy(subType: "move", source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationMove;
+        updateOperationAddMoveCopy(subType: "copy", source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationCopy;
+        updateOperationAddMoveCopy(subType: "add" | "move" | "copy", source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationAdd | import("./RoundTripTypes").UpdateOperationMove | import("./RoundTripTypes").UpdateOperationCopy;
+        updateOperationAdd(source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationAdd;
+        isUpdateOperationAdd(obj: object): obj is SubTyped<"updateOperation", "add">;
+        updateOperationMove(source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationMove;
+        isUpdateOperationMove(obj: object): obj is SubTyped<"updateOperation", "move">;
+        updateOperationCopy(source: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, destination: import("./RoundTripTypes").GraphRefDefault | import("./RoundTripTypes").GraphRefSpecific, silent: boolean, loc: SourceLocation): import("./RoundTripTypes").UpdateOperationCopy;
+        isUpdateOperationCopy(obj: object): obj is SubTyped<"updateOperation", "copy">;
+        updateOperationInsDelDataWhere(subType: "insertdata", data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationInsertData;
+        updateOperationInsDelDataWhere(subType: "deletedata", data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDeleteData;
+        updateOperationInsDelDataWhere(subType: "deletewhere", data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDeleteWhere;
+        updateOperationInsDelDataWhere(subType: "insertdata" | "deletedata" | "deletewhere", data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationInsertData | import("./RoundTripTypes").UpdateOperationDeleteData | import("./RoundTripTypes").UpdateOperationDeleteWhere;
+        updateOperationInsertData(data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationInsertData;
+        isUpdateOperationInsertData(obj: object): obj is SubTyped<"updateOperation", "insertdata">;
+        updateOperationDeleteData(data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDeleteData;
+        isUpdateOperationDeleteData(obj: object): obj is SubTyped<"updateOperation", "deletedata">;
+        updateOperationDeleteWhere(data: import("./RoundTripTypes").Quads[], loc: SourceLocation): import("./RoundTripTypes").UpdateOperationDeleteWhere;
+        isUpdateOperationDeleteWhere(obj: object): obj is SubTyped<"updateOperation", "deletewhere">;
+        updateOperationModify(loc: SourceLocation, insert: import("./RoundTripTypes").Quads[] | undefined, del: import("./RoundTripTypes").Quads[] | undefined, where: import("./RoundTripTypes").PatternGroup, from: DatasetClauses, graph?: TermIri | undefined): import("./RoundTripTypes").UpdateOperationModify;
+        isUpdateOperationModify(obj: object): obj is SubTyped<"updateOperation", "modify">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        __blankNodeCounter: number;
+        resetBlankNodeCounter(): void;
+        isTerm(x: object): x is Typed<"term">;
+        blankNode(label: undefined | string, loc: SourceLocation): TermBlank;
+        isTermBlank(obj: object): obj is SubTyped<"term", "blankNode">;
+        literalTerm(loc: SourceLocation, value: string, lang?: undefined): import("./RoundTripTypes").TermLiteralStr;
+        literalTerm(loc: SourceLocation, value: string, lang: string): import("./RoundTripTypes").TermLiteralLangStr;
+        literalTerm(loc: SourceLocation, value: string, iri: TermIri): import("./RoundTripTypes").TermLiteralTyped;
+        literalTerm(loc: SourceLocation, value: string, langOrIri?: string | TermIri): import("./RoundTripTypes").TermLiteral;
+        isTermLiteral(obj: object): obj is SubTyped<"term", "literal">;
+        isTermLiteralLangStr(obj: object): obj is SubTyped<"term", "literal"> & {
+            langOrIri: string;
+        };
+        isTermLiteralStr(obj: object): obj is SubTyped<"term", "literal"> & {
+            langOrIri: undefined;
+        };
+        isTermLiteralTyped(obj: object): obj is SubTyped<"term", "literal"> & {
+            langOrIri: SubTyped<"term", "namedNode">;
+        };
+        variable(value: string, loc: SourceLocation): TermVariable;
+        isTermVariable(obj: object): obj is SubTyped<"term", "variable">;
+        namedNode(loc: SourceLocation, value: string, prefix?: undefined): import("./RoundTripTypes").TermIriFull;
+        namedNode(loc: SourceLocation, value: string, prefix: string): import("./RoundTripTypes").TermIriPrefixed;
+        isTermNamed(obj: object): obj is SubTyped<"term", "namedNode">;
+        isTermNamedPrefixed(obj: object): obj is SubTyped<"term", "namedNode"> & {
+            prefix: string;
+        };
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isSolutionModifier(obj: object): obj is Typed<"solutionModifier">;
+        solutionModifierHaving(having: import("./RoundTripTypes").Expression[], loc: SourceLocation): import("./RoundTripTypes").SolutionModifierHaving;
+        isSolutionModifierHaving(obj: object): obj is SubTyped<"solutionModifier", "having">;
+        solutionModifierOrder(orderDefs: import("./RoundTripTypes").Ordering[], loc: SourceLocation): import("./RoundTripTypes").SolutionModifierOrder;
+        isSolutionModifierOrder(obj: object): obj is SubTyped<"solutionModifier", "order">;
+        solutionModifierLimitOffset(limit: number | undefined, offset: number | undefined, loc: SourceLocation): import("./RoundTripTypes").SolutionModifierLimitOffset;
+        isSolutionModifierLimitOffset(obj: object): obj is SubTyped<"solutionModifier", "limitOffset">;
+        solutionModifierGroup(groupings: (import("./RoundTripTypes").Expression | import("./RoundTripTypes").SolutionModifierGroupBind)[], loc: SourceLocation): import("./RoundTripTypes").SolutionModifierGroup;
+        isSolutionModifierGroup(obj: object): obj is SubTyped<"solutionModifier", "group">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isQuery(obj: object): obj is Typed<"query">;
+        isQuerySelect(obj: object): obj is SubTyped<"query", "select">;
+        queryConstruct(loc: SourceLocation, context: import("./RoundTripTypes").ContextDefinition[], template: PatternBgp, where: import("./RoundTripTypes").PatternGroup, solutionModifiers: import("./RoundTripTypes").SolutionModifiers, datasets: DatasetClauses, values?: import("./RoundTripTypes").PatternValues): import("./RoundTripTypes").QueryConstruct;
+        isQueryConstruct(obj: object): obj is SubTyped<"query", "construct">;
+        isQueryDescribe(obj: object): obj is SubTyped<"query", "describe">;
+        isQueryAsk(obj: object): obj is SubTyped<"query", "ask">;
+        querySelect(arg: Omit<import("./RoundTripTypes").QuerySelect, "type" | "subType" | "loc">, loc: SourceLocation): import("./RoundTripTypes").QuerySelect;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isPattern(obj: object): obj is Typed<"pattern">;
+        patternBgp(triples: import("./RoundTripTypes").BasicGraphPattern, loc: SourceLocation): PatternBgp;
+        isPatternBgp(obj: object): obj is SubTyped<"pattern", "bgp">;
+        patternGroup(patterns: import("./RoundTripTypes").Pattern[], loc: SourceLocation): import("./RoundTripTypes").PatternGroup;
+        isPatternGroup(obj: object): obj is SubTyped<"pattern", "group">;
+        patternGraph(name: TermIri | TermVariable, patterns: import("./RoundTripTypes").Pattern[], loc: SourceLocation): import("./RoundTripTypes").PatternGraph;
+        isPatternGraph(obj: object): obj is SubTyped<"pattern", "graph">;
+        patternOptional(patterns: import("./RoundTripTypes").Pattern[], loc: SourceLocation): import("./RoundTripTypes").PatternOptional;
+        isPatternOptional(obj: object): obj is SubTyped<"pattern", "optional">;
+        patternValues(values: import("./RoundTripTypes").ValuePatternRow[], loc: SourceLocation): import("./RoundTripTypes").PatternValues;
+        isPatternValues(obj: object): obj is SubTyped<"pattern", "values">;
+        patternFilter(expression: import("./RoundTripTypes").Expression, loc: SourceLocation): import("./RoundTripTypes").PatternFilter;
+        isPatternFilter(obj: object): obj is SubTyped<"pattern", "filter">;
+        patternBind(expression: import("./RoundTripTypes").Expression, variable: TermVariable, loc: SourceLocation): import("./RoundTripTypes").PatternBind;
+        isPatternBind(obj: object): obj is SubTyped<"pattern", "bind">;
+        patternUnion(patterns: import("./RoundTripTypes").PatternGroup[], loc: SourceLocation): import("./RoundTripTypes").PatternUnion;
+        isPatternUnion(obj: object): obj is SubTyped<"pattern", "union">;
+        patternMinus(patterns: import("./RoundTripTypes").Pattern[], loc: SourceLocation): import("./RoundTripTypes").PatternMinus;
+        isPatternMinus(obj: object): obj is SubTyped<"pattern", "minus">;
+        patternService(name: TermIri | TermVariable, patterns: import("./RoundTripTypes").Pattern[], silent: boolean, loc: SourceLocation): import("./RoundTripTypes").PatternService;
+        isPatternService(obj: object): obj is SubTyped<"pattern", "service">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isPathPure(obj: object): obj is Typed<"path">;
+        path(subType: "|", items: (TermIri | import("./RoundTripTypes").PathNegatedElt)[], loc: SourceLocation): import("./RoundTripTypes").PathAlternativeLimited;
+        path(subType: "!", items: [TermIri | import("./RoundTripTypes").PathNegatedElt | import("./RoundTripTypes").PathAlternativeLimited], loc: SourceLocation): import("./RoundTripTypes").PathNegated;
+        path(subType: "^", items: [TermIri], loc: SourceLocation): import("./RoundTripTypes").PathNegatedElt;
+        path(subType: import("./RoundTripTypes").PathModified["subType"], item: [import("./RoundTripTypes").Path], loc: SourceLocation): import("./RoundTripTypes").PathModified;
+        path(subType: "|" | "/", items: import("./RoundTripTypes").Path[], loc: SourceLocation): import("./RoundTripTypes").PropertyPathChain;
+        isPathOfType<T extends U[], U extends string>(obj: object, subTypes: T): obj is SubTyped<"path", U>;
+        isPathChain(obj: object): obj is SubTyped<"path", "|" | "/">;
+        isPathModified(obj: object): obj is SubTyped<"path", "?" | "*" | "+" | "^">;
+        isPathNegatedElt(obj: object): obj is SubTyped<"path", "^"> & {
+            items: [SubTyped<"term", "namedNode">];
+        };
+        isPathNegated(obj: object): obj is SubTyped<"path", "!">;
+        isPathAlternativeLimited(obj: object): obj is SubTyped<"path", "|"> & {
+            items: (SubTyped<"term", "namedNode"> | (SubTyped<"path", "^"> & {
+                items: [SubTyped<"term", "namedNode">];
+            }))[];
+        };
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isGraphRef(obj: object): obj is Typed<"graphRef">;
+        graphRefDefault(loc: SourceLocation): import("./RoundTripTypes").GraphRefDefault;
+        isGraphRefDefault(graphRef: object): graphRef is SubTyped<"graphRef", "default">;
+        graphRefNamed(loc: SourceLocation): import("./RoundTripTypes").GraphRefNamed;
+        isGraphRefNamed(graphRef: object): graphRef is SubTyped<"graphRef", "named">;
+        graphRefAll(loc: SourceLocation): import("./RoundTripTypes").GraphRefAll;
+        isGraphRefAll(graphRef: object): graphRef is SubTyped<"graphRef", "all">;
+        graphRefSpecific(graph: TermIri, loc: SourceLocation): import("./RoundTripTypes").GraphRefSpecific;
+        isGraphRefSpecific(graphRef: object): graphRef is SubTyped<"graphRef", "specific">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        isExpressionPure(obj: object): obj is Typed<"expression">;
+        formatOperator(operator: string): string;
+        expressionOperation<Args extends import("./RoundTripTypes").Expression[]>(operator: string, args: Args, loc: SourceLocation): import("@traqula/core").Node & {
+            type: "expression";
+            subType: string;
+        } & {
+            subType: "operation";
+            operator: string;
+            args: import("./RoundTripTypes").Expression[];
+        } & {
+            args: Args;
+        };
+        isExpressionOperator(obj: object): obj is SubTyped<"expression", "operation">;
+        expressionFunctionCall<Args extends import("./RoundTripTypes").Expression[]>(functionOp: TermIri, args: Args, distinct: boolean, loc: SourceLocation): import("@traqula/core").Node & {
+            type: "expression";
+            subType: string;
+        } & {
+            subType: "functionCall";
+            function: TermIri;
+            distinct: boolean;
+            args: import("./RoundTripTypes").Expression[];
+        } & {
+            args: Args;
+        };
+        isExpressionFunctionCall(obj: object): obj is SubTyped<"expression", "functionCall">;
+        expressionPatternOperation(operator: string, args: import("./RoundTripTypes").PatternGroup, loc: SourceLocation): import("./RoundTripTypes").ExpressionPatternOperation;
+        isExpressionPatternOperation(obj: object): obj is SubTyped<"expression", "patternOperation">;
+        aggregate(aggregation: string, distinct: boolean, arg: import("./RoundTripTypes").Expression, separator: undefined, loc: SourceLocation): import("./RoundTripTypes").ExpressionAggregateDefault;
+        aggregate(aggregation: string, distinct: boolean, arg: Wildcard, separator: undefined, loc: SourceLocation): import("./RoundTripTypes").ExpressionAggregateOnWildcard;
+        aggregate(aggregation: string, distinct: boolean, arg: import("./RoundTripTypes").Expression, separator: string, loc: SourceLocation): import("./RoundTripTypes").ExpressionAggregateSeparator;
+        aggregate(aggregation: string, distinct: boolean, arg: import("./RoundTripTypes").Expression | Wildcard, separator: string | undefined, loc: SourceLocation): import("./RoundTripTypes").ExpressionAggregate;
+        isExpressionAggregate(obj: object): obj is SubTyped<"expression", "aggregate">;
+        isExpressionAggregateSeparator(obj: object): obj is SubTyped<"expression", "aggregate"> & {
+            separator: string;
+        };
+        isExpressionAggregateOnWildcard(obj: object): obj is SubTyped<"expression", "aggregate"> & {
+            expression: [Typed<"wildcard">];
+        };
+        isExpressionAggregateDefault(obj: object): obj is SubTyped<"expression", "aggregate"> & {
+            expression: [import("./RoundTripTypes").Expression];
+        };
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & {
+    new (...args: any[]): {
+        contextDefinitionPrefix(loc: SourceLocation, key: string, value: import("./RoundTripTypes").TermIriFull): import("./RoundTripTypes").ContextDefinitionPrefix;
+        isContextDefinitionPrefix(contextDef: object): contextDef is SubTyped<"contextDef", "prefix">;
+        contextDefinitionBase(loc: SourceLocation, value: import("./RoundTripTypes").TermIriFull): import("./RoundTripTypes").ContextDefinitionBase;
+        isContextDefinitionBase(contextDef: object): contextDef is SubTyped<"contextDef", "base">;
+        wrap<T>(val: T, loc: SourceLocation): import("@traqula/core").Wrap<T>;
+        isLocalized(obj: unknown): obj is import("@traqula/core").Localized;
+        sourceLocation(...elements: (undefined | import("chevrotain").IToken | import("@traqula/core").Localized)[]): SourceLocation;
+        sourceLocationNoMaterialize(): import("@traqula/core").SourceLocationNoMaterialize;
+        dematerialized<T extends import("@traqula/core").Node>(arg: T): T & {
+            loc: import("@traqula/core").SourceLocationNoMaterialize;
+        };
+        safeObjectTransform(value: unknown, mapper: (some: object) => any): any;
+        forcedAutoGenTree<T extends object>(obj: T): T;
+        forceMaterialized<T extends import("@traqula/core").Node>(arg: T): T;
+        isSourceLocation(loc: object): loc is SourceLocation;
+        sourceLocationSource(start: number, end: number): import("@traqula/core").SourceLocationSource;
+        gen(): import("@traqula/core").SourceLocationNodeAutoGenerate;
+        isSourceLocationSource(loc: object): loc is import("@traqula/core").SourceLocationSource;
+        isSourceLocationStringReplace(loc: object): loc is import("@traqula/core").SourceLocationStringReplace;
+        sourceLocationNodeReplaceUnsafe(loc: SourceLocation): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(location: import("@traqula/core").SourceLocationSource): import("@traqula/core").SourceLocationNodeReplace;
+        sourceLocationNodeReplace(start: number, end: number): import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeReplace(loc: object): loc is import("@traqula/core").SourceLocationNodeReplace;
+        isSourceLocationNodeAutoGenerate(loc: object): loc is import("@traqula/core").SourceLocationNodeAutoGenerate;
+        nodeShouldPrint(node: import("@traqula/core").Localized): boolean;
+        printFilter(node: import("@traqula/core").Localized, callback: () => void): void;
+        isSourceLocationNoMaterialize(loc: object): loc is import("@traqula/core").SourceLocationNoMaterialize;
+        isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>;
+        isOfSubType<Type extends string, SubType extends string>(obj: object, type: Type, subType: SubType): obj is SubTyped<Type, SubType>;
+    };
+} & typeof CoreFactory;
+export declare class Factory extends Factory_base {
+    alwaysSparql11(obj: object): obj is Sparql11Nodes;
+    isPath(obj: object): obj is SubTyped<'term', 'namedNode'> | Typed<'path'>;
+    isExpression(obj: object): obj is SubTyped<'term', 'namedNode' | 'variable' | 'literal'> | Typed<'expression'>;
+    graphNodeIdentifier(graphNode: GraphNode): Term;
+    triple(subject: TripleNesting['subject'], predicate: TripleNesting['predicate'], object: TripleNesting['object'], loc?: SourceLocation): TripleNesting;
+    isTriple(obj: object): obj is Typed<'triple'>;
+    datasetClauses(clauses: DatasetClauses['clauses'], loc: SourceLocation): DatasetClauses;
+    isDatasetClauses(obj: object): obj is Typed<'datasetClauses'>;
+    wildcard(loc: SourceLocation): Wildcard;
+    isWildcard(obj: object): obj is Typed<'wildcard'>;
+    isTripleCollection(obj: object): obj is Typed<'tripleCollection'>;
+    tripleCollectionBlankNodeProperties(identifier: TermBlank, triples: TripleNesting[], loc: SourceLocation): TripleCollectionBlankNodeProperties;
+    isTripleCollectionBlankNodeProperties(obj: object): obj is SubTyped<'tripleCollection', 'blankNodeProperties'>;
+    tripleCollectionList(identifier: TermBlank, triples: TripleNesting[], loc: SourceLocation): TripleCollectionList;
+    isTripleCollectionList(obj: object): obj is SubTyped<'tripleCollection', 'list'>;
+    graphQuads(graph: TermIri | TermVariable, triples: PatternBgp, loc: SourceLocation): GraphQuads;
+    isGraphQuads(obj: object): obj is GraphQuads;
+    isUpdate(obj: object): obj is Update;
+}
+export {};

package/lib/factory.js

@@ -0,0 +1,105 @@
+import { CoreFactory } from '@traqula/core';
+import { ContextFactoryMixin } from './factoryMixins/ContextFactory';
+import { ExpressionFactoryMixin } from './factoryMixins/ExpressionFactory';
+import { GraphRefFactoryMixin } from './factoryMixins/GraphRefFactory';
+import { asArg } from './factoryMixins/mixins';
+import { PathFactoryMixin } from './factoryMixins/PathFactory';
+import { PatternFactoryMixin } from './factoryMixins/Patternfactory';
+import { QueryFactoryMixin } from './factoryMixins/QueryFactory';
+import { SolutionModifiersFactoryMixin } from './factoryMixins/SolutionModifiersFactory';
+import { TermFactoryMixin } from './factoryMixins/TermFactory';
+import { UpdateOperationFactoryMixin } from './factoryMixins/UpdateOperationFactory';
+export class Factory extends asArg(CoreFactory)
+    .call(ContextFactoryMixin)
+    .call(ExpressionFactoryMixin)
+    .call(GraphRefFactoryMixin)
+    .call(PathFactoryMixin)
+    .call(PatternFactoryMixin)
+    .call(QueryFactoryMixin)
+    .call(SolutionModifiersFactoryMixin)
+    .call(TermFactoryMixin)
+    .call(UpdateOperationFactoryMixin)
+    .returns() {
+    alwaysSparql11(obj) {
+        return true;
+    }
+    isPath(obj) {
+        return this.isPathPure(obj) || this.isTermNamed(obj);
+    }
+    isExpression(obj) {
+        return this.isExpressionPure(obj) || this.isTermNamed(obj) || this.isTermVariable(obj) || this.isTermLiteral(obj);
+    }
+    graphNodeIdentifier(graphNode) {
+        return graphNode.type === 'tripleCollection' ? graphNode.identifier : graphNode;
+    }
+    triple(subject, predicate, object, loc) {
+        return {
+            type: 'triple',
+            subject,
+            predicate,
+            object,
+            loc: loc ?? this.sourceLocation(subject, predicate, object),
+        };
+    }
+    isTriple(obj) {
+        return this.isOfType(obj, 'triple');
+    }
+    datasetClauses(clauses, loc) {
+        return {
+            type: 'datasetClauses',
+            clauses,
+            loc,
+        };
+    }
+    isDatasetClauses(obj) {
+        return this.isOfType(obj, 'datasetClauses');
+    }
+    wildcard(loc) {
+        return { type: 'wildcard', loc };
+    }
+    isWildcard(obj) {
+        return this.isOfType(obj, 'wildcard');
+    }
+    isTripleCollection(obj) {
+        return this.isOfType(obj, 'tripleCollection');
+    }
+    tripleCollectionBlankNodeProperties(identifier, triples, loc) {
+        return {
+            type: 'tripleCollection',
+            subType: 'blankNodeProperties',
+            identifier,
+            triples,
+            loc,
+        };
+    }
+    isTripleCollectionBlankNodeProperties(obj) {
+        return this.isOfSubType(obj, 'tripleCollection', 'blankNodeProperties');
+    }
+    tripleCollectionList(identifier, triples, loc) {
+        return {
+            type: 'tripleCollection',
+            subType: 'list',
+            identifier,
+            triples,
+            loc,
+        };
+    }
+    isTripleCollectionList(obj) {
+        return this.isOfSubType(obj, 'tripleCollection', 'list');
+    }
+    graphQuads(graph, triples, loc) {
+        return {
+            type: 'graph',
+            graph,
+            triples,
+            loc,
+        };
+    }
+    isGraphQuads(obj) {
+        return super.isOfType(obj, 'graph');
+    }
+    isUpdate(obj) {
+        return super.isOfType(obj, 'update');
+    }
+}
+//# sourceMappingURL=factory.js.map

package/lib/factory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.js","sourceRoot":"","sources":["factory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SourceLocation, SubTyped, Typed } from '@traqula/core';\nimport { CoreFactory } from '@traqula/core';\nimport { ContextFactoryMixin } from './factoryMixins/ContextFactory';\nimport { ExpressionFactoryMixin } from './factoryMixins/ExpressionFactory';\nimport { GraphRefFactoryMixin } from './factoryMixins/GraphRefFactory';\nimport { asArg } from './factoryMixins/mixins';\nimport { PathFactoryMixin } from './factoryMixins/PathFactory';\nimport { PatternFactoryMixin } from './factoryMixins/Patternfactory';\nimport { QueryFactoryMixin } from './factoryMixins/QueryFactory';\nimport { SolutionModifiersFactoryMixin } from './factoryMixins/SolutionModifiersFactory';\nimport { TermFactoryMixin } from './factoryMixins/TermFactory';\nimport { UpdateOperationFactoryMixin } from './factoryMixins/UpdateOperationFactory';\nimport type {\n  DatasetClauses,\n  GraphNode,\n  GraphQuads,\n  PatternBgp,\n  Sparql11Nodes,\n  Term,\n  TermBlank,\n  TermIri,\n  TermVariable,\n  TripleCollectionBlankNodeProperties,\n  TripleCollectionList,\n  TripleNesting,\n  Update,\n  Wildcard,\n} from './RoundTripTypes';\n\nexport class Factory extends asArg(CoreFactory)\n  .call(ContextFactoryMixin)\n  .call(ExpressionFactoryMixin)\n  .call(GraphRefFactoryMixin)\n  .call(PathFactoryMixin)\n  .call(PatternFactoryMixin)\n  .call(QueryFactoryMixin)\n  .call(SolutionModifiersFactoryMixin)\n  .call(TermFactoryMixin)\n  .call(UpdateOperationFactoryMixin)\n  .returns() {\n  public alwaysSparql11(obj: object): obj is Sparql11Nodes {\n    return true;\n  }\n\n  public isPath(obj: object): obj is SubTyped<'term', 'namedNode'> | Typed<'path'> {\n    return this.isPathPure(obj) || this.isTermNamed(obj);\n  }\n\n  public isExpression(obj: object):\n    obj is SubTyped<'term', 'namedNode' | 'variable' | 'literal'> | Typed<'expression'> {\n    return this.isExpressionPure(obj) || this.isTermNamed(obj) || this.isTermVariable(obj) || this.isTermLiteral(obj);\n  }\n\n  public graphNodeIdentifier(graphNode: GraphNode): Term {\n    return graphNode.type === 'tripleCollection' ? graphNode.identifier : graphNode;\n  }\n\n  public triple(\n    subject: TripleNesting['subject'],\n    predicate: TripleNesting['predicate'],\n    object: TripleNesting['object'],\n    loc?: SourceLocation,\n  ): TripleNesting {\n    return {\n      type: 'triple',\n      subject,\n      predicate,\n      object,\n      loc: loc ?? this.sourceLocation(subject, predicate, object),\n    };\n  }\n\n  public isTriple(obj: object): obj is Typed<'triple'> {\n    return this.isOfType(obj, 'triple');\n  }\n\n  public datasetClauses(clauses: DatasetClauses['clauses'], loc: SourceLocation): DatasetClauses {\n    return {\n      type: 'datasetClauses',\n      clauses,\n      loc,\n    };\n  }\n\n  public isDatasetClauses(obj: object): obj is Typed<'datasetClauses'> {\n    return this.isOfType(obj, 'datasetClauses');\n  }\n\n  public wildcard(loc: SourceLocation): Wildcard {\n    return { type: 'wildcard', loc };\n  }\n\n  public isWildcard(obj: object): obj is Typed<'wildcard'> {\n    return this.isOfType(obj, 'wildcard');\n  }\n\n  public isTripleCollection(obj: object): obj is Typed<'tripleCollection'> {\n    return this.isOfType(obj, 'tripleCollection');\n  }\n\n  public tripleCollectionBlankNodeProperties(\n    identifier: TermBlank,\n    triples: TripleNesting[],\n    loc: SourceLocation,\n  ): TripleCollectionBlankNodeProperties {\n    return {\n      type: 'tripleCollection',\n      subType: 'blankNodeProperties',\n      identifier,\n      triples,\n      loc,\n    };\n  }\n\n  public isTripleCollectionBlankNodeProperties(obj: object):\n    obj is SubTyped<'tripleCollection', 'blankNodeProperties'> {\n    return this.isOfSubType(obj, 'tripleCollection', 'blankNodeProperties');\n  }\n\n  public tripleCollectionList(\n    identifier: TermBlank,\n    triples: TripleNesting[],\n    loc: SourceLocation,\n  ): TripleCollectionList {\n    return {\n      type: 'tripleCollection',\n      subType: 'list',\n      identifier,\n      triples,\n      loc,\n    };\n  }\n\n  public isTripleCollectionList(obj: object):\n    obj is SubTyped<'tripleCollection', 'list'> {\n    return this.isOfSubType(obj, 'tripleCollection', 'list');\n  }\n\n  public graphQuads(graph: TermIri | TermVariable, triples: PatternBgp, loc: SourceLocation): GraphQuads {\n    return {\n      type: 'graph',\n      graph,\n      triples,\n      loc,\n    };\n  }\n\n  public isGraphQuads(obj: object): obj is GraphQuads {\n    return super.isOfType(obj, 'graph');\n  }\n\n  public isUpdate(obj: object): obj is Update {\n    return super.isOfType(obj, 'update');\n  }\n}\n"]}