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

package/lib/factoryMixins/Patternfactory.js

@@ -0,0 +1,98 @@
+const nodeType = 'pattern';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function PatternFactoryMixin(Base) {
+    return class PatternFactory extends Base {
+        isPattern(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        patternBgp(triples, loc) {
+            return { type: nodeType, subType: 'bgp', triples, loc };
+        }
+        isPatternBgp(obj) {
+            return this.isOfSubType(obj, nodeType, 'bgp');
+        }
+        patternGroup(patterns, loc) {
+            return { type: nodeType, subType: 'group', patterns, loc };
+        }
+        isPatternGroup(obj) {
+            return this.isOfSubType(obj, nodeType, 'group');
+        }
+        patternGraph(name, patterns, loc) {
+            return { type: nodeType, subType: 'graph', name, patterns, loc };
+        }
+        isPatternGraph(obj) {
+            return this.isOfSubType(obj, nodeType, 'graph');
+        }
+        patternOptional(patterns, loc) {
+            return { type: nodeType, subType: 'optional', patterns, loc };
+        }
+        isPatternOptional(obj) {
+            return this.isOfSubType(obj, nodeType, 'optional');
+        }
+        patternValues(values, loc) {
+            return { type: nodeType, subType: 'values', values, loc };
+        }
+        isPatternValues(obj) {
+            return this.isOfSubType(obj, nodeType, 'values');
+        }
+        patternFilter(expression, loc) {
+            return {
+                type: nodeType,
+                subType: 'filter',
+                expression,
+                loc,
+            };
+        }
+        isPatternFilter(obj) {
+            return this.isOfSubType(obj, nodeType, 'filter');
+        }
+        patternBind(expression, variable, loc) {
+            return {
+                type: nodeType,
+                subType: 'bind',
+                expression,
+                variable,
+                loc,
+            };
+        }
+        isPatternBind(obj) {
+            return this.isOfSubType(obj, nodeType, 'bind');
+        }
+        patternUnion(patterns, loc) {
+            return {
+                type: nodeType,
+                subType: 'union',
+                patterns,
+                loc,
+            };
+        }
+        isPatternUnion(obj) {
+            return this.isOfSubType(obj, nodeType, 'union');
+        }
+        patternMinus(patterns, loc) {
+            return {
+                type: nodeType,
+                subType: 'minus',
+                patterns,
+                loc,
+            };
+        }
+        isPatternMinus(obj) {
+            return this.isOfSubType(obj, nodeType, 'minus');
+        }
+        patternService(name, patterns, silent, loc) {
+            return {
+                type: nodeType,
+                subType: 'service',
+                silent,
+                name,
+                patterns,
+                loc,
+            };
+        }
+        isPatternService(obj) {
+            return this.isOfSubType(obj, nodeType, 'service');
+        }
+    };
+}
+//# sourceMappingURL=Patternfactory.js.map

package/lib/factoryMixins/Patternfactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Patternfactory.js","sourceRoot":"","sources":["Patternfactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  BasicGraphPattern,\n  Expression,\n  Pattern,\n  PatternBgp,\n  PatternBind,\n  PatternFilter,\n  PatternGraph,\n  PatternGroup,\n  PatternMinus,\n  PatternOptional,\n  PatternService,\n  PatternUnion,\n  PatternValues,\n  TermIri,\n  TermVariable,\n  ValuePatternRow,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'pattern';\nconst nodeType: NodeType = 'pattern';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function PatternFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class PatternFactory extends Base {\n    public isPattern(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public patternBgp(triples: BasicGraphPattern, loc: SourceLocation): PatternBgp {\n      return { type: nodeType, subType: 'bgp', triples, loc };\n    }\n\n    public isPatternBgp(obj: object): obj is SubTyped<NodeType, 'bgp'> {\n      return this.isOfSubType(obj, nodeType, 'bgp');\n    }\n\n    public patternGroup(patterns: Pattern[], loc: SourceLocation): PatternGroup {\n      return { type: nodeType, subType: 'group', patterns, loc };\n    }\n\n    public isPatternGroup(obj: object): obj is SubTyped<NodeType, 'group'> {\n      return this.isOfSubType(obj, nodeType, 'group');\n    }\n\n    public patternGraph(name: TermIri | TermVariable, patterns: Pattern[], loc: SourceLocation): PatternGraph {\n      return { type: nodeType, subType: 'graph', name, patterns, loc };\n    }\n\n    public isPatternGraph(obj: object): obj is SubTyped<NodeType, 'graph'> {\n      return this.isOfSubType(obj, nodeType, 'graph');\n    }\n\n    public patternOptional(patterns: Pattern[], loc: SourceLocation): PatternOptional {\n      return { type: nodeType, subType: 'optional', patterns, loc };\n    }\n\n    public isPatternOptional(obj: object): obj is SubTyped<NodeType, 'optional'> {\n      return this.isOfSubType(obj, nodeType, 'optional');\n    }\n\n    public patternValues(values: ValuePatternRow[], loc: SourceLocation): PatternValues {\n      return { type: nodeType, subType: 'values', values, loc };\n    }\n\n    public isPatternValues(obj: object): obj is SubTyped<NodeType, 'values'> {\n      return this.isOfSubType(obj, nodeType, 'values');\n    }\n\n    public patternFilter(expression: Expression, loc: SourceLocation): PatternFilter {\n      return {\n        type: nodeType,\n        subType: 'filter',\n        expression,\n        loc,\n      };\n    }\n\n    public isPatternFilter(obj: object): obj is SubTyped<NodeType, 'filter'> {\n      return this.isOfSubType(obj, nodeType, 'filter');\n    }\n\n    public patternBind(\n      expression: Expression,\n      variable: TermVariable,\n      loc: SourceLocation,\n    ): PatternBind {\n      return {\n        type: nodeType,\n        subType: 'bind',\n        expression,\n        variable,\n        loc,\n      };\n    }\n\n    public isPatternBind(obj: object): obj is SubTyped<NodeType, 'bind'> {\n      return this.isOfSubType(obj, nodeType, 'bind');\n    }\n\n    public patternUnion(patterns: PatternGroup[], loc: SourceLocation): PatternUnion {\n      return {\n        type: nodeType,\n        subType: 'union',\n        patterns,\n        loc,\n      };\n    }\n\n    public isPatternUnion(obj: object): obj is SubTyped<NodeType, 'union'> {\n      return this.isOfSubType(obj, nodeType, 'union');\n    }\n\n    public patternMinus(patterns: Pattern[], loc: SourceLocation): PatternMinus {\n      return {\n        type: nodeType,\n        subType: 'minus',\n        patterns,\n        loc,\n      };\n    }\n\n    public isPatternMinus(obj: object): obj is SubTyped<NodeType, 'minus'> {\n      return this.isOfSubType(obj, nodeType, 'minus');\n    }\n\n    public patternService(\n      name: TermIri | TermVariable,\n      patterns: Pattern[],\n      silent: boolean,\n      loc: SourceLocation,\n    ): PatternService {\n      return {\n        type: nodeType,\n        subType: 'service',\n        silent,\n        name,\n        patterns,\n        loc,\n      };\n    }\n\n    public isPatternService(obj: object): obj is SubTyped<NodeType, 'service'> {\n      return this.isOfSubType(obj, nodeType, 'service');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/QueryFactory.d.ts

@@ -0,0 +1,41 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { ContextDefinition, DatasetClauses, PatternBgp, PatternGroup, PatternValues, QueryConstruct, QuerySelect, SolutionModifiers } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'query';
+export declare function QueryFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isQuery(obj: object): obj is Typed<NodeType>;
+        isQuerySelect(obj: object): obj is SubTyped<NodeType, "select">;
+        queryConstruct(loc: SourceLocation, context: ContextDefinition[], template: PatternBgp, where: PatternGroup, solutionModifiers: SolutionModifiers, datasets: DatasetClauses, values?: PatternValues): QueryConstruct;
+        isQueryConstruct(obj: object): obj is SubTyped<NodeType, "construct">;
+        isQueryDescribe(obj: object): obj is SubTyped<NodeType, "describe">;
+        isQueryAsk(obj: object): obj is SubTyped<NodeType, "ask">;
+        querySelect(arg: Omit<QuerySelect, "type" | "subType" | "loc">, loc: SourceLocation): 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>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/QueryFactory.js

@@ -0,0 +1,43 @@
+const nodeType = 'query';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function QueryFactoryMixin(Base) {
+    return class QueryFactory extends Base {
+        isQuery(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        isQuerySelect(obj) {
+            return this.isOfSubType(obj, nodeType, 'select');
+        }
+        queryConstruct(loc, context, template, where, solutionModifiers, datasets, values) {
+            return {
+                type: 'query',
+                subType: 'construct',
+                context,
+                template,
+                where,
+                solutionModifiers,
+                datasets,
+                values,
+                loc,
+            };
+        }
+        isQueryConstruct(obj) {
+            return this.isOfSubType(obj, nodeType, 'construct');
+        }
+        isQueryDescribe(obj) {
+            return this.isOfSubType(obj, nodeType, 'describe');
+        }
+        isQueryAsk(obj) {
+            return this.isOfSubType(obj, nodeType, 'ask');
+        }
+        querySelect(arg, loc) {
+            return {
+                type: nodeType,
+                subType: 'select',
+                ...arg,
+                loc,
+            };
+        }
+    };
+}
+//# sourceMappingURL=QueryFactory.js.map

package/lib/factoryMixins/QueryFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryFactory.js","sourceRoot":"","sources":["QueryFactory.ts"],"names":[],"mappings":"AAcA,MAAM,QAAQ,GAAa,OAAO,CAAC;AAEnC,4DAA4D;AAC5D,MAAM,UAAU,iBAAiB,CAAyC,IAAW;IACnF,OAAO,MAAM,YAAa,SAAQ,IAAI;QAC7B,OAAO,CAAC,GAAW;YACxB,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QAEM,aAAa,CAAC,GAAW;YAC9B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;QAEM,cAAc,CACnB,GAAmB,EACnB,OAA4B,EAC5B,QAAoB,EACpB,KAAmB,EACnB,iBAAoC,EACpC,QAAwB,EACxB,MAAsB;YAEtB,OAAO;gBACL,IAAI,EAAE,OAAO;gBACb,OAAO,EAAE,WAAW;gBACpB,OAAO;gBACP,QAAQ;gBACR,KAAK;gBACL,iBAAiB;gBACjB,QAAQ;gBACR,MAAM;gBACN,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,gBAAgB,CAAC,GAAW;YACjC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,WAAW,CAAC,CAAC;QACtD,CAAC;QAEM,eAAe,CAAC,GAAW;YAChC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrD,CAAC;QAEM,UAAU,CAAC,GAAW;YAC3B,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;QAChD,CAAC;QAEM,WAAW,CAAC,GAAkD,EAAE,GAAmB;YACxF,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,QAAQ;gBACjB,GAAG,GAAG;gBACN,GAAG;aACJ,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  ContextDefinition,\n  DatasetClauses,\n  PatternBgp,\n  PatternGroup,\n  PatternValues,\n  QueryConstruct,\n  QuerySelect,\n  SolutionModifiers,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'query';\nconst nodeType: NodeType = 'query';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function QueryFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class QueryFactory extends Base {\n    public isQuery(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public isQuerySelect(obj: object): obj is SubTyped<NodeType, 'select'> {\n      return this.isOfSubType(obj, nodeType, 'select');\n    }\n\n    public queryConstruct(\n      loc: SourceLocation,\n      context: ContextDefinition[],\n      template: PatternBgp,\n      where: PatternGroup,\n      solutionModifiers: SolutionModifiers,\n      datasets: DatasetClauses,\n      values?: PatternValues,\n    ): QueryConstruct {\n      return {\n        type: 'query',\n        subType: 'construct',\n        context,\n        template,\n        where,\n        solutionModifiers,\n        datasets,\n        values,\n        loc,\n      };\n    }\n\n    public isQueryConstruct(obj: object): obj is SubTyped<NodeType, 'construct'> {\n      return this.isOfSubType(obj, nodeType, 'construct');\n    }\n\n    public isQueryDescribe(obj: object): obj is SubTyped<NodeType, 'describe'> {\n      return this.isOfSubType(obj, nodeType, 'describe');\n    }\n\n    public isQueryAsk(obj: object): obj is SubTyped<NodeType, 'ask'> {\n      return this.isOfSubType(obj, nodeType, 'ask');\n    }\n\n    public querySelect(arg: Omit<QuerySelect, 'type' | 'subType' | 'loc'>, loc: SourceLocation): QuerySelect {\n      return {\n        type: nodeType,\n        subType: 'select',\n        ...arg,\n        loc,\n      };\n    }\n  };\n}\n"]}

package/lib/factoryMixins/SolutionModifiersFactory.d.ts

@@ -0,0 +1,43 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { Expression, Ordering, SolutionModifierGroup, SolutionModifierGroupBind, SolutionModifierHaving, SolutionModifierLimitOffset, SolutionModifierOrder } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'solutionModifier';
+export declare function SolutionModifiersFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isSolutionModifier(obj: object): obj is Typed<NodeType>;
+        solutionModifierHaving(having: Expression[], loc: SourceLocation): SolutionModifierHaving;
+        isSolutionModifierHaving(obj: object): obj is SubTyped<NodeType, "having">;
+        solutionModifierOrder(orderDefs: Ordering[], loc: SourceLocation): SolutionModifierOrder;
+        isSolutionModifierOrder(obj: object): obj is SubTyped<NodeType, "order">;
+        solutionModifierLimitOffset(limit: number | undefined, offset: number | undefined, loc: SourceLocation): SolutionModifierLimitOffset;
+        isSolutionModifierLimitOffset(obj: object): obj is SubTyped<NodeType, "limitOffset">;
+        solutionModifierGroup(groupings: (Expression | SolutionModifierGroupBind)[], loc: SourceLocation): SolutionModifierGroup;
+        isSolutionModifierGroup(obj: object): obj is SubTyped<NodeType, "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>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/SolutionModifiersFactory.js

@@ -0,0 +1,55 @@
+const nodeType = 'solutionModifier';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function SolutionModifiersFactoryMixin(Base) {
+    return class SolutionModifiersFactory extends Base {
+        isSolutionModifier(obj) {
+            return this.isOfType(obj, nodeType);
+        }
+        solutionModifierHaving(having, loc) {
+            return {
+                type: nodeType,
+                subType: 'having',
+                having,
+                loc,
+            };
+        }
+        isSolutionModifierHaving(obj) {
+            return this.isOfSubType(obj, nodeType, 'having');
+        }
+        solutionModifierOrder(orderDefs, loc) {
+            return {
+                type: nodeType,
+                subType: 'order',
+                orderDefs,
+                loc,
+            };
+        }
+        isSolutionModifierOrder(obj) {
+            return this.isOfSubType(obj, nodeType, 'order');
+        }
+        solutionModifierLimitOffset(limit, offset, loc) {
+            return {
+                type: nodeType,
+                subType: 'limitOffset',
+                limit,
+                offset,
+                loc,
+            };
+        }
+        isSolutionModifierLimitOffset(obj) {
+            return this.isOfSubType(obj, nodeType, 'limitOffset');
+        }
+        solutionModifierGroup(groupings, loc) {
+            return {
+                type: 'solutionModifier',
+                subType: 'group',
+                groupings,
+                loc,
+            };
+        }
+        isSolutionModifierGroup(obj) {
+            return this.isOfSubType(obj, nodeType, 'group');
+        }
+    };
+}
+//# sourceMappingURL=SolutionModifiersFactory.js.map

package/lib/factoryMixins/SolutionModifiersFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SolutionModifiersFactory.js","sourceRoot":"","sources":["SolutionModifiersFactory.ts"],"names":[],"mappings":"AAaA,MAAM,QAAQ,GAAa,kBAAkB,CAAC;AAE9C,4DAA4D;AAC5D,MAAM,UAAU,6BAA6B,CAAyC,IAAW;IAC/F,OAAO,MAAM,wBAAyB,SAAQ,IAAI;QACzC,kBAAkB,CAAC,GAAW;YACnC,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QAEM,sBAAsB,CAAC,MAAoB,EAAE,GAAmB;YACrE,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,QAAQ;gBACjB,MAAM;gBACN,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,wBAAwB,CAAC,GAAW;YACzC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC;QACnD,CAAC;QAEM,qBAAqB,CAAC,SAAqB,EAAE,GAAmB;YACrE,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,OAAO;gBAChB,SAAS;gBACT,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,uBAAuB,CAAC,GAAW;YACxC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAClD,CAAC;QAEM,2BAA2B,CAChC,KAAyB,EACzB,MAA0B,EAC1B,GAAmB;YAEnB,OAAO;gBACL,IAAI,EAAE,QAAQ;gBACd,OAAO,EAAE,aAAa;gBACtB,KAAK;gBACL,MAAM;gBACN,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,6BAA6B,CAAC,GAAW;YAC9C,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,aAAa,CAAC,CAAC;QACxD,CAAC;QAEM,qBAAqB,CAAC,SAAqD,EAAE,GAAmB;YAErG,OAAO;gBACL,IAAI,EAAE,kBAAkB;gBACxB,OAAO,EAAE,OAAO;gBAChB,SAAS;gBACT,GAAG;aACJ,CAAC;QACJ,CAAC;QAEM,uBAAuB,CAAC,GAAW;YACxC,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;QAClD,CAAC;KACF,CAAC;AACJ,CAAC","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  Expression,\n  Ordering,\n  SolutionModifierGroup,\n  SolutionModifierGroupBind,\n  SolutionModifierHaving,\n  SolutionModifierLimitOffset,\n  SolutionModifierOrder,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'solutionModifier';\nconst nodeType: NodeType = 'solutionModifier';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function SolutionModifiersFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class SolutionModifiersFactory extends Base {\n    public isSolutionModifier(obj: object): obj is Typed<NodeType> {\n      return this.isOfType(obj, nodeType);\n    }\n\n    public solutionModifierHaving(having: Expression[], loc: SourceLocation): SolutionModifierHaving {\n      return {\n        type: nodeType,\n        subType: 'having',\n        having,\n        loc,\n      };\n    }\n\n    public isSolutionModifierHaving(obj: object): obj is SubTyped<NodeType, 'having'> {\n      return this.isOfSubType(obj, nodeType, 'having');\n    }\n\n    public solutionModifierOrder(orderDefs: Ordering[], loc: SourceLocation): SolutionModifierOrder {\n      return {\n        type: nodeType,\n        subType: 'order',\n        orderDefs,\n        loc,\n      };\n    }\n\n    public isSolutionModifierOrder(obj: object): obj is SubTyped<NodeType, 'order'> {\n      return this.isOfSubType(obj, nodeType, 'order');\n    }\n\n    public solutionModifierLimitOffset(\n      limit: number | undefined,\n      offset: number | undefined,\n      loc: SourceLocation,\n    ): SolutionModifierLimitOffset {\n      return {\n        type: nodeType,\n        subType: 'limitOffset',\n        limit,\n        offset,\n        loc,\n      };\n    }\n\n    public isSolutionModifierLimitOffset(obj: object): obj is SubTyped<NodeType, 'limitOffset'> {\n      return this.isOfSubType(obj, nodeType, 'limitOffset');\n    }\n\n    public solutionModifierGroup(groupings: (Expression | SolutionModifierGroupBind)[], loc: SourceLocation):\n    SolutionModifierGroup {\n      return {\n        type: 'solutionModifier',\n        subType: 'group',\n        groupings,\n        loc,\n      };\n    }\n\n    public isSolutionModifierGroup(obj: object): obj is SubTyped<NodeType, 'group'> {\n      return this.isOfSubType(obj, nodeType, 'group');\n    }\n  };\n}\n"]}

package/lib/factoryMixins/TermFactory.d.ts

@@ -0,0 +1,76 @@
+import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';
+import type { TermBlank, TermIri, TermIriFull, TermIriPrefixed, TermLiteral, TermLiteralLangStr, TermLiteralStr, TermLiteralTyped, TermVariable } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'term';
+export declare function TermFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    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<NodeType, "blankNode">;
+        /**
+         * String, no lang, no type
+         */
+        literalTerm(loc: SourceLocation, value: string, lang?: undefined): TermLiteralStr;
+        /**
+         * String with a language tag
+         */
+        literalTerm(loc: SourceLocation, value: string, lang: string): TermLiteralLangStr;
+        /**
+         * Lexical form with a type
+         */
+        literalTerm(loc: SourceLocation, value: string, iri: TermIri): TermLiteralTyped;
+        literalTerm(loc: SourceLocation, value: string, langOrIri?: string | TermIri): TermLiteral;
+        isTermLiteral(obj: object): obj is SubTyped<NodeType, "literal">;
+        isTermLiteralLangStr(obj: object): obj is SubTyped<NodeType, "literal"> & {
+            langOrIri: string;
+        };
+        isTermLiteralStr(obj: object): obj is SubTyped<NodeType, "literal"> & {
+            langOrIri: undefined;
+        };
+        isTermLiteralTyped(obj: object): obj is SubTyped<NodeType, "literal"> & {
+            langOrIri: SubTyped<NodeType, "namedNode">;
+        };
+        variable(value: string, loc: SourceLocation): TermVariable;
+        isTermVariable(obj: object): obj is SubTyped<NodeType, "variable">;
+        /**
+         * A namednode with fully defined with a uri.
+         */
+        namedNode(loc: SourceLocation, value: string, prefix?: undefined): TermIriFull;
+        /**
+         * A namednode defined using a prefix
+         */
+        namedNode(loc: SourceLocation, value: string, prefix: string): TermIriPrefixed;
+        isTermNamed(obj: object): obj is SubTyped<NodeType, "namedNode">;
+        isTermNamedPrefixed(obj: object): obj is SubTyped<NodeType, "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>;
+    };
+} & TBase;
+export {};

package/lib/factoryMixins/TermFactory.js

@@ -0,0 +1,84 @@
+const nodeType = 'term';
+// eslint-disable-next-line ts/explicit-function-return-type
+export function TermFactoryMixin(Base) {
+    return class TermFactory extends Base {
+        constructor() {
+            super(...arguments);
+            this.__blankNodeCounter = 0;
+        }
+        resetBlankNodeCounter() {
+            this.__blankNodeCounter = 0;
+        }
+        isTerm(x) {
+            return this.isOfType(x, 'term');
+        }
+        blankNode(label, loc) {
+            const base = {
+                type: 'term',
+                subType: 'blankNode',
+                loc,
+            };
+            if (label === undefined) {
+                return { ...base, label: `g_${this.__blankNodeCounter++}` };
+            }
+            return { ...base, label: `e_${label}` };
+        }
+        isTermBlank(obj) {
+            return this.isOfSubType(obj, nodeType, 'blankNode');
+        }
+        literalTerm(loc, value, langOrIri) {
+            return {
+                type: nodeType,
+                subType: 'literal',
+                value,
+                langOrIri,
+                loc,
+            };
+        }
+        isTermLiteral(obj) {
+            return this.isOfSubType(obj, nodeType, 'literal');
+        }
+        isTermLiteralLangStr(obj) {
+            return this.isTermLiteral(obj) && typeof obj.langOrIri === 'string';
+        }
+        isTermLiteralStr(obj) {
+            return this.isTermLiteral(obj) && typeof obj.langOrIri === 'undefined';
+        }
+        isTermLiteralTyped(obj) {
+            const casted = obj;
+            return this.isTermLiteral(obj) && typeof casted.langOrIri === 'object' &&
+                casted.langOrIri !== null && this.isTermNamed(casted.langOrIri);
+        }
+        variable(value, loc) {
+            return {
+                type: nodeType,
+                subType: 'variable',
+                value,
+                loc,
+            };
+        }
+        isTermVariable(obj) {
+            return this.isOfSubType(obj, nodeType, 'variable');
+        }
+        namedNode(loc, value, prefix) {
+            const base = {
+                type: nodeType,
+                subType: 'namedNode',
+                value,
+                loc,
+            };
+            if (prefix === undefined) {
+                return base;
+            }
+            return { ...base, prefix };
+        }
+        isTermNamed(obj) {
+            return this.isOfSubType(obj, nodeType, 'namedNode');
+        }
+        isTermNamedPrefixed(obj) {
+            const casted = obj;
+            return this.isTermNamed(obj) && typeof casted.prefix === 'string';
+        }
+    };
+}
+//# sourceMappingURL=TermFactory.js.map

package/lib/factoryMixins/TermFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TermFactory.js","sourceRoot":"","sources":["TermFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import type { CoreFactory, SourceLocation, Typed, SubTyped } from '@traqula/core';\nimport type {\n  TermBlank,\n  TermIri,\n  TermIriFull,\n  TermIriPrefixed,\n  TermLiteral,\n  TermLiteralLangStr,\n  TermLiteralStr,\n  TermLiteralTyped,\n  TermVariable,\n} from '../RoundTripTypes';\nimport type { Constructor } from './mixins';\n\ntype NodeType = 'term';\nconst nodeType: NodeType = 'term';\n\n// eslint-disable-next-line ts/explicit-function-return-type\nexport function TermFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase) {\n  return class TermFactory extends Base {\n    public __blankNodeCounter = 0;\n\n    public resetBlankNodeCounter(): void {\n      this.__blankNodeCounter = 0;\n    }\n\n    public isTerm(x: object): x is Typed<'term'> {\n      return this.isOfType(x, 'term');\n    }\n\n    public blankNode(label: undefined | string, loc: SourceLocation): TermBlank {\n      const base = <const>{\n        type: 'term',\n        subType: 'blankNode',\n        loc,\n      };\n      if (label === undefined) {\n        return { ...base, label: `g_${this.__blankNodeCounter++}` };\n      }\n      return { ...base, label: `e_${label}` };\n    }\n\n    public isTermBlank(obj: object): obj is SubTyped<NodeType, 'blankNode'> {\n      return this.isOfSubType(obj, nodeType, 'blankNode');\n    }\n\n    /**\n     * String, no lang, no type\n     */\n    public literalTerm(loc: SourceLocation, value: string, lang?: undefined): TermLiteralStr;\n    /**\n     * String with a language tag\n     */\n    public literalTerm(loc: SourceLocation, value: string, lang: string): TermLiteralLangStr;\n    /**\n     * Lexical form with a type\n     */\n    public literalTerm(loc: SourceLocation, value: string, iri: TermIri): TermLiteralTyped;\n    public literalTerm(loc: SourceLocation, value: string, langOrIri?: string | TermIri): TermLiteral;\n    public literalTerm(loc: SourceLocation, value: string, langOrIri?: string | TermIri): TermLiteral {\n      return {\n        type: nodeType,\n        subType: 'literal',\n        value,\n        langOrIri,\n        loc,\n      };\n    }\n\n    public isTermLiteral(obj: object): obj is SubTyped<NodeType, 'literal'> {\n      return this.isOfSubType(obj, nodeType, 'literal');\n    }\n\n    public isTermLiteralLangStr(obj: object): obj is SubTyped<NodeType, 'literal'> & { langOrIri: string } {\n      return this.isTermLiteral(obj) && typeof (<{ langOrIri?: unknown }>obj).langOrIri === 'string';\n    }\n\n    public isTermLiteralStr(obj: object): obj is SubTyped<NodeType, 'literal'> & { langOrIri: undefined } {\n      return this.isTermLiteral(obj) && typeof (<{ langOrIri?: unknown }>obj).langOrIri === 'undefined';\n    }\n\n    public isTermLiteralTyped(obj: object):\n      obj is SubTyped<NodeType, 'literal'> & { langOrIri: SubTyped<NodeType, 'namedNode'> } {\n      const casted = <{ langOrIri?: unknown }>obj;\n      return this.isTermLiteral(obj) && typeof casted.langOrIri === 'object' &&\n        casted.langOrIri !== null && this.isTermNamed(casted.langOrIri);\n    }\n\n    public variable(value: string, loc: SourceLocation): TermVariable {\n      return {\n        type: nodeType,\n        subType: 'variable',\n        value,\n        loc,\n      };\n    }\n\n    public isTermVariable(obj: object): obj is SubTyped<NodeType, 'variable'> {\n      return this.isOfSubType(obj, nodeType, 'variable');\n    }\n\n    /**\n     * A namednode with fully defined with a uri.\n     */\n    public namedNode(loc: SourceLocation, value: string, prefix?: undefined): TermIriFull;\n    /**\n     * A namednode defined using a prefix\n     */\n    public namedNode(loc: SourceLocation, value: string, prefix: string): TermIriPrefixed;\n    public namedNode(loc: SourceLocation, value: string, prefix?: string): TermIriFull | TermIriPrefixed {\n      const base = <const>{\n        type: nodeType,\n        subType: 'namedNode',\n        value,\n        loc,\n      };\n      if (prefix === undefined) {\n        return base;\n      }\n      return { ...base, prefix };\n    }\n\n    public isTermNamed(obj: object): obj is SubTyped<NodeType, 'namedNode'> {\n      return this.isOfSubType(obj, nodeType, 'namedNode');\n    }\n\n    public isTermNamedPrefixed(obj: object): obj is SubTyped<NodeType, 'namedNode'> & { prefix: string } {\n      const casted = <{ prefix?: unknown }>obj;\n      return this.isTermNamed(obj) && typeof casted.prefix === 'string';\n    }\n  };\n}\n"]}

package/lib/factoryMixins/UpdateOperationFactory.d.ts

@@ -0,0 +1,68 @@
+import type { CoreFactory, SourceLocation, SubTyped, Typed } from '@traqula/core';
+import type { DatasetClauses, GraphRef, GraphRefDefault, GraphRefSpecific, PatternGroup, Quads, TermIri, UpdateOperationAdd, UpdateOperationClear, UpdateOperationCopy, UpdateOperationCreate, UpdateOperationDeleteData, UpdateOperationDeleteWhere, UpdateOperationDrop, UpdateOperationInsertData, UpdateOperationLoad, UpdateOperationModify, UpdateOperationMove } from '../RoundTripTypes';
+import type { Constructor } from './mixins';
+type NodeType = 'updateOperation';
+export declare function UpdateOperationFactoryMixin<TBase extends Constructor<CoreFactory>>(Base: TBase): {
+    new (...args: any[]): {
+        isUpdateOperation(obj: object): obj is Typed<NodeType>;
+        updateOperationLoad(loc: SourceLocation, source: TermIri, silent: boolean, destination?: GraphRefSpecific | undefined): UpdateOperationLoad;
+        isUpdateOperationLoad(obj: object): obj is SubTyped<NodeType, "load">;
+        updateOperationClearDrop(subType: "clear", silent: boolean, destination: GraphRef, loc: SourceLocation): UpdateOperationClear;
+        updateOperationClearDrop(subType: "drop", silent: boolean, destination: GraphRef, loc: SourceLocation): UpdateOperationDrop;
+        updateOperationClearDrop(subType: "clear" | "drop", silent: boolean, destination: GraphRef, loc: SourceLocation): UpdateOperationClear | UpdateOperationDrop;
+        updateOperationClear(destination: GraphRef, silent: boolean, loc: SourceLocation): UpdateOperationClear;
+        isUpdateOperationClear(obj: object): obj is SubTyped<NodeType, "clear">;
+        updateOperationDrop(destination: GraphRef, silent: boolean, loc: SourceLocation): UpdateOperationDrop;
+        isUpdateOperationDrop(obj: object): obj is SubTyped<NodeType, "drop">;
+        updateOperationCreate(destination: GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationCreate;
+        isUpdateOperationCreate(obj: object): obj is SubTyped<NodeType, "create">;
+        updateOperationAddMoveCopy(subType: "add", source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationAdd;
+        updateOperationAddMoveCopy(subType: "move", source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationMove;
+        updateOperationAddMoveCopy(subType: "copy", source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationCopy;
+        updateOperationAddMoveCopy(subType: "add" | "move" | "copy", source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy;
+        updateOperationAdd(source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationAdd;
+        isUpdateOperationAdd(obj: object): obj is SubTyped<NodeType, "add">;
+        updateOperationMove(source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationMove;
+        isUpdateOperationMove(obj: object): obj is SubTyped<NodeType, "move">;
+        updateOperationCopy(source: GraphRefDefault | GraphRefSpecific, destination: GraphRefDefault | GraphRefSpecific, silent: boolean, loc: SourceLocation): UpdateOperationCopy;
+        isUpdateOperationCopy(obj: object): obj is SubTyped<NodeType, "copy">;
+        updateOperationInsDelDataWhere(subType: "insertdata", data: Quads[], loc: SourceLocation): UpdateOperationInsertData;
+        updateOperationInsDelDataWhere(subType: "deletedata", data: Quads[], loc: SourceLocation): UpdateOperationDeleteData;
+        updateOperationInsDelDataWhere(subType: "deletewhere", data: Quads[], loc: SourceLocation): UpdateOperationDeleteWhere;
+        updateOperationInsDelDataWhere(subType: "insertdata" | "deletedata" | "deletewhere", data: Quads[], loc: SourceLocation): UpdateOperationInsertData | UpdateOperationDeleteData | UpdateOperationDeleteWhere;
+        updateOperationInsertData(data: Quads[], loc: SourceLocation): UpdateOperationInsertData;
+        isUpdateOperationInsertData(obj: object): obj is SubTyped<NodeType, "insertdata">;
+        updateOperationDeleteData(data: Quads[], loc: SourceLocation): UpdateOperationDeleteData;
+        isUpdateOperationDeleteData(obj: object): obj is SubTyped<NodeType, "deletedata">;
+        updateOperationDeleteWhere(data: Quads[], loc: SourceLocation): UpdateOperationDeleteWhere;
+        isUpdateOperationDeleteWhere(obj: object): obj is SubTyped<NodeType, "deletewhere">;
+        updateOperationModify(loc: SourceLocation, insert: Quads[] | undefined, del: Quads[] | undefined, where: PatternGroup, from: DatasetClauses, graph?: TermIri | undefined): UpdateOperationModify;
+        isUpdateOperationModify(obj: object): obj is SubTyped<NodeType, "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>;
+    };
+} & TBase;
+export {};