Class AstFactory

A factory that helps you create, and check types for AST nodes for SPARQL 1.1

Hierarchy (View Summary)

UpdateOperationFactory<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & { prototype: __type<any>; new (...args: any[]): __type } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & {
        prototype: __type<any>;
        new (...args: any[]): __type;
    } & typeof AstCoreFactory,
    this,
> & __type<
    { prototype: __type<any>; new (...args: any[]): __type } & typeof AstCoreFactory,
    this,
> & __type<typeof AstCoreFactory, this> & AstCoreFactory<this>
- AstFactory
  - AstFactory

Index

Constructors

constructor

new AstFactory(args?: Partial<AstCoreFactoryArgs>): AstFactory
Parameters
- Optionalargs: Partial<AstCoreFactoryArgs>
Returns AstFactory
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().constructor
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:11

Properties

__blankNodeCounter

__blankNodeCounter: number = 0

tracksSourceLocation

tracksSourceLocation: boolean

Whether the AstFactory can track sources, if not, the sourceLocation function returns autoGen. Default true

Methods

aggregate

aggregate(
    aggregation: string,
    distinct: boolean,
    arg: Expression,
    separator: undefined,
    loc: SourceLocation,
): ExpressionAggregateDefault
Parameters
- aggregation: string
- distinct: boolean
- arg: Expression
- separator: undefined
- loc: SourceLocation
Returns ExpressionAggregateDefault
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().aggregate
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:87
aggregate(
    aggregation: string,
    distinct: boolean,
    arg: Wildcard,
    separator: undefined,
    loc: SourceLocation,
): ExpressionAggregateOnWildcard
Parameters
- aggregation: string
- distinct: boolean
- arg: Wildcard
- separator: undefined
- loc: SourceLocation
Returns ExpressionAggregateOnWildcard
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().aggregate
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:94
aggregate(
    aggregation: string,
    distinct: boolean,
    arg: Expression,
    separator: string,
    loc: SourceLocation,
): ExpressionAggregateSeparator
Parameters
- aggregation: string
- distinct: boolean
- arg: Expression
- separator: string
- loc: SourceLocation
Returns ExpressionAggregateSeparator
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().aggregate
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:101
aggregate(
    aggregation: string,
    distinct: boolean,
    arg: Expression | Wildcard,
    separator: undefined | string,
    loc: SourceLocation,
): ExpressionAggregate
Parameters
- aggregation: string
- distinct: boolean
- arg: Expression | Wildcard
- separator: undefined | string
- loc: SourceLocation
Returns ExpressionAggregate
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().aggregate
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:108

alwaysSparql11

alwaysSparql11(obj: object): obj is Sparql11Nodes
Parameters
- obj: object
Returns obj is Sparql11Nodes
- Defined in rules-sparql-1-1/lib/astFactory.ts:44

contextDefinitionBase

contextDefinitionBase(
loc: SourceLocation,
value: TermIriFull,
): ContextDefinitionBase
Parameters
- loc: SourceLocation
- value: TermIriFull
Returns ContextDefinitionBase
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().contextDefinitionBase
- Defined in rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts:29

contextDefinitionPrefix

contextDefinitionPrefix(
    loc: SourceLocation,
    key: string,
    value: TermIriFull,
): ContextDefinitionPrefix
Parameters
- loc: SourceLocation
- key: string
- value: TermIriFull
Returns ContextDefinitionPrefix
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().contextDefinitionPrefix
- Defined in rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts:15

datasetClauses

datasetClauses(
clauses: { clauseType: "default" | "named"; value: TermIri }[],
loc: SourceLocation,
): DatasetClauses
Parameters
- clauses: { clauseType: "default" | "named"; value: TermIri }[]
- loc: SourceLocation
Returns DatasetClauses
- Defined in rules-sparql-1-1/lib/astFactory.ts:80

dematerialized

dematerialized<T extends Node>(arg: T): T
Returns a copy of the argument that is not materialized
Type Parameters
- T extends Node
Parameters
- arg: T
Returns T
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().dematerialized
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:19

expressionFunctionCall

expressionFunctionCall<Args extends Expression[]>(
    functionOp: TermIri,
    args: Args,
    distinct: boolean,
    loc: SourceLocation,
): Node & { subType: string; type: "expression" } & {
    args: Expression[];
    distinct: boolean;
    function: TermIri;
    subType: "functionCall";
} & { args: Args }
Type Parameters
- Args extends Expression[]
Parameters
- functionOp: TermIri
- args: Args
- distinct: boolean
- loc: SourceLocation
Returns Node & { subType: string; type: "expression" } & {
    args: Expression[];
    distinct: boolean;
    function: TermIri;
    subType: "functionCall";
} & { args: Args }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().expressionFunctionCall
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:49

expressionOperation

expressionOperation<Args extends Expression[]>(
    operator: string,
    args: Args,
    loc: SourceLocation,
): Node & { subType: string; type: "expression" } & {
    args: Expression[];
    operator: string;
    subType: "operation";
} & { args: Args }
Type Parameters
- Args extends Expression[]
Parameters
- operator: string
- args: Args
- loc: SourceLocation
Returns Node & { subType: string; type: "expression" } & {
    args: Expression[];
    operator: string;
    subType: "operation";
} & { args: Args }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().expressionOperation
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:31

expressionPatternOperation

expressionPatternOperation(
    operator: string,
    args: PatternGroup,
    loc: SourceLocation,
): ExpressionPatternOperation
Parameters
- operator: string
- args: PatternGroup
- loc: SourceLocation
Returns ExpressionPatternOperation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().expressionPatternOperation
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:69

forcedAutoGenTree

forcedAutoGenTree<T extends object>(obj: T): T
Type Parameters
- T extends object
Parameters
- obj: T
Returns T
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().forcedAutoGenTree
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:21

forceMaterialized

forceMaterialized<T extends Node>(arg: T): T
Type Parameters
- T extends Node
Parameters
- arg: T
Returns T
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().forceMaterialized
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:22

formatOperator

formatOperator(operator: string): string
Parameters
- operator: string
Returns string
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().formatOperator
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:27

gen

gen(): SourceLocationNodeAutoGenerate
Returns SourceLocationNodeAutoGenerate
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().gen
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:30

graphNodeIdentifier

graphNodeIdentifier(graphNode: GraphNode): Term
Parameters
- graphNode: GraphNode
Returns Term
- Defined in rules-sparql-1-1/lib/astFactory.ts:57

graphQuads

graphQuads(
    graph: TermIri | TermVariable,
    triples: PatternBgp,
    loc: SourceLocation,
): GraphQuads
Parameters
- graph: TermIri | TermVariable
- triples: PatternBgp
- loc: SourceLocation
Returns GraphQuads
- Defined in rules-sparql-1-1/lib/astFactory.ts:142

graphRefAll

graphRefAll(loc: SourceLocation): GraphRefAll
Parameters
- loc: SourceLocation
Returns GraphRefAll
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().graphRefAll
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:45

graphRefDefault

graphRefDefault(loc: SourceLocation): GraphRefDefault
Parameters
- loc: SourceLocation
Returns GraphRefDefault
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().graphRefDefault
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:21

graphRefNamed

graphRefNamed(loc: SourceLocation): GraphRefNamed
Parameters
- loc: SourceLocation
Returns GraphRefNamed
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().graphRefNamed
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:33

graphRefSpecific

graphRefSpecific(graph: TermIri, loc: SourceLocation): GraphRefSpecific
Parameters
- graph: TermIri
- loc: SourceLocation
Returns GraphRefSpecific
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().graphRefSpecific
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:57

isContextDefinitionBase

isContextDefinitionBase(
contextDef: object,
): contextDef is SubTyped<"contextDef", "base">
Parameters
- contextDef: object
Returns contextDef is SubTyped<"contextDef", "base">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isContextDefinitionBase
- Defined in rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts:38

isContextDefinitionPrefix

isContextDefinitionPrefix(
contextDef: object,
): contextDef is SubTyped<"contextDef", "prefix">
Parameters
- contextDef: object
Returns contextDef is SubTyped<"contextDef", "prefix">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isContextDefinitionPrefix
- Defined in rules-sparql-1-1/lib/factoryMixins/ContextFactory.ts:25

isDatasetClauses

isDatasetClauses(obj: object): obj is Typed<"datasetClauses">
Parameters
- obj: object
Returns obj is Typed<"datasetClauses">
- Defined in rules-sparql-1-1/lib/astFactory.ts:88

isExpression

isExpression(
    obj: object,
): obj is
    | Typed<"expression">
    | SubTyped<"term", "variable" | "literal" | "namedNode">
Parameters
- obj: object
Returns obj is
| Typed<"expression">
| SubTyped<"term", "variable" | "literal" | "namedNode">
- Defined in rules-sparql-1-1/lib/astFactory.ts:52

isExpressionAggregate

isExpressionAggregate(obj: object): obj is SubTyped<"expression", "aggregate">
Parameters
- obj: object
Returns obj is SubTyped<"expression", "aggregate">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionAggregate
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:138

isExpressionAggregateDefault

isExpressionAggregateDefault(
obj: object,
): obj is SubTyped<"expression", "aggregate"> & { expression: [Expression] }
Parameters
- obj: object
Returns obj is SubTyped<"expression", "aggregate"> & { expression: [Expression] }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionAggregateDefault
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:154

isExpressionAggregateOnWildcard

isExpressionAggregateOnWildcard(
obj: object,
): obj is SubTyped<"expression", "aggregate"> & {
expression: [Typed<"wildcard">];
}
Parameters
- obj: object
Returns obj is SubTyped<"expression", "aggregate"> & { expression: [Typed<"wildcard">] }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionAggregateOnWildcard
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:147

isExpressionAggregateSeparator

isExpressionAggregateSeparator(
obj: object,
): obj is SubTyped<"expression", "aggregate"> & { separator: string }
Parameters
- obj: object
Returns obj is SubTyped<"expression", "aggregate"> & { separator: string }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionAggregateSeparator
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:142

isExpressionFunctionCall

isExpressionFunctionCall(
obj: object,
): obj is SubTyped<"expression", "functionCall">
Parameters
- obj: object
Returns obj is SubTyped<"expression", "functionCall">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionFunctionCall
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:65

isExpressionOperator

isExpressionOperator(obj: object): obj is SubTyped<"expression", "operation">
Parameters
- obj: object
Returns obj is SubTyped<"expression", "operation">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionOperator
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:45

isExpressionPatternOperation

isExpressionPatternOperation(
obj: object,
): obj is SubTyped<"expression", "patternOperation">
Parameters
- obj: object
Returns obj is SubTyped<"expression", "patternOperation">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionPatternOperation
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:83

isExpressionPure

isExpressionPure(obj: object): obj is Typed<"expression">
Parameters
- obj: object
Returns obj is Typed<"expression">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isExpressionPure
- Defined in rules-sparql-1-1/lib/factoryMixins/ExpressionFactory.ts:23

isGraphQuads

isGraphQuads(obj: object): obj is GraphQuads
Parameters
- obj: object
Returns obj is GraphQuads
- Defined in rules-sparql-1-1/lib/astFactory.ts:151

isGraphRef

isGraphRef(obj: object): obj is Typed<"graphRef">
Parameters
- obj: object
Returns obj is Typed<"graphRef">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isGraphRef
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:17

isGraphRefAll

isGraphRefAll(graphRef: object): graphRef is SubTyped<"graphRef", "all">
Parameters
- graphRef: object
Returns graphRef is SubTyped<"graphRef", "all">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isGraphRefAll
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:53

isGraphRefDefault

isGraphRefDefault(graphRef: object): graphRef is SubTyped<"graphRef", "default">
Parameters
- graphRef: object
Returns graphRef is SubTyped<"graphRef", "default">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isGraphRefDefault
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:29

isGraphRefNamed

isGraphRefNamed(graphRef: object): graphRef is SubTyped<"graphRef", "named">
Parameters
- graphRef: object
Returns graphRef is SubTyped<"graphRef", "named">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isGraphRefNamed
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:41

isGraphRefSpecific

isGraphRefSpecific(
graphRef: object,
): graphRef is SubTyped<"graphRef", "specific">
Parameters
- graphRef: object
Returns graphRef is SubTyped<"graphRef", "specific">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isGraphRefSpecific
- Defined in rules-sparql-1-1/lib/factoryMixins/GraphRefFactory.ts:66

isLocalized

isLocalized(obj: unknown): obj is Localized
Parameters
- obj: unknown
Returns obj is Localized
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isLocalized
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:13

isOfSubType

isOfSubType<Type extends string, SubType extends string>(
    obj: object,
    type: Type,
    subType: SubType,
): obj is SubTyped<Type, SubType>
Type Parameters
- Type extends string
- SubType extends string
Parameters
- obj: object
- type: Type
- subType: SubType
Returns obj is SubTyped<Type, SubType>
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isOfSubType
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:43

isOfType

isOfType<Type extends string>(obj: object, type: Type): obj is Typed<Type>
Type Parameters
- Type extends string
Parameters
- obj: object
- type: Type
Returns obj is Typed<Type>
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isOfType
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:42

isPath

isPath(obj: object): obj is SubTyped<"term", "namedNode"> | Typed<"path">
Parameters
- obj: object
Returns obj is SubTyped<"term", "namedNode"> | Typed<"path">
- Defined in rules-sparql-1-1/lib/astFactory.ts:48

isPathAlternativeLimited

isPathAlternativeLimited(
obj: object,
): obj is SubTyped<"path", "|"> & {
items: (SubTyped<"term", "namedNode"> | RawNegatedElt)[];
}
Parameters
- obj: object
Returns obj is SubTyped<"path", "|"> & {
items: (SubTyped<"term", "namedNode"> | RawNegatedElt)[];
}
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathAlternativeLimited
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:103

isPathChain

isPathChain(obj: object): obj is SubTyped<"path", "|" | "/">
Parameters
- obj: object
Returns obj is SubTyped<"path", "|" | "/">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathChain
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:84

isPathModified

isPathModified(obj: object): obj is SubTyped<"path", "?" | "*" | "+" | "^">
Parameters
- obj: object
Returns obj is SubTyped<"path", "?" | "*" | "+" | "^">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathModified
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:88

isPathNegated

isPathNegated(obj: object): obj is SubTyped<"path", "!">
Parameters
- obj: object
Returns obj is SubTyped<"path", "!">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathNegated
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:99

isPathNegatedElt

isPathNegatedElt(obj: object): obj is RawNegatedElt
Parameters
- obj: object
Returns obj is RawNegatedElt
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathNegatedElt
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:93

isPathOfType

isPathOfType<T extends U[], U extends string>(
obj: object,
subTypes: T,
): obj is SubTyped<"path", U>
Type Parameters
- T extends U[]
- U extends string
Parameters
- obj: object
- subTypes: T
Returns obj is SubTyped<"path", U>
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathOfType
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:80

isPathPure

isPathPure(obj: object): obj is Typed<"path">
Parameters
- obj: object
Returns obj is Typed<"path">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPathPure
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:21

isPattern

isPattern(obj: object): obj is Typed<"pattern">
Parameters
- obj: object
Returns obj is Typed<"pattern">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPattern
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:28

isPatternBgp

isPatternBgp(obj: object): obj is SubTyped<"pattern", "bgp">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "bgp">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternBgp
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:36

isPatternBind

isPatternBind(obj: object): obj is SubTyped<"pattern", "bind">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "bind">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternBind
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:99

isPatternFilter

isPatternFilter(obj: object): obj is SubTyped<"pattern", "filter">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "filter">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternFilter
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:81

isPatternGraph

isPatternGraph(obj: object): obj is SubTyped<"pattern", "graph">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "graph">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternGraph
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:52

isPatternGroup

isPatternGroup(obj: object): obj is SubTyped<"pattern", "group">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "group">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternGroup
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:44

isPatternMinus

isPatternMinus(obj: object): obj is SubTyped<"pattern", "minus">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "minus">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternMinus
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:125

isPatternOptional

isPatternOptional(obj: object): obj is SubTyped<"pattern", "optional">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "optional">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternOptional
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:60

isPatternService

isPatternService(obj: object): obj is SubTyped<"pattern", "service">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "service">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternService
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:145

isPatternUnion

isPatternUnion(obj: object): obj is SubTyped<"pattern", "union">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "union">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternUnion
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:112

isPatternValues

isPatternValues(obj: object): obj is SubTyped<"pattern", "values">
Parameters
- obj: object
Returns obj is SubTyped<"pattern", "values">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPatternValues
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:68

isPrintingLoc

isPrintingLoc(loc: SourceLocation): boolean
Parameters
- loc: SourceLocation
Returns boolean
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isPrintingLoc
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:39

isQuery

isQuery(obj: object): obj is Typed<"query">
Parameters
- obj: object
Returns obj is Typed<"query">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isQuery
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:20

isQueryAsk

isQueryAsk(obj: object): obj is SubTyped<"query", "ask">
Parameters
- obj: object
Returns obj is SubTyped<"query", "ask">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isQueryAsk
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:58

isQueryConstruct

isQueryConstruct(obj: object): obj is SubTyped<"query", "construct">
Parameters
- obj: object
Returns obj is SubTyped<"query", "construct">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isQueryConstruct
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:50

isQueryDescribe

isQueryDescribe(obj: object): obj is SubTyped<"query", "describe">
Parameters
- obj: object
Returns obj is SubTyped<"query", "describe">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isQueryDescribe
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:54

isQuerySelect

isQuerySelect(obj: object): obj is SubTyped<"query", "select">
Parameters
- obj: object
Returns obj is SubTyped<"query", "select">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isQuerySelect
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:24

isSolutionModifier

isSolutionModifier(obj: object): obj is Typed<"solutionModifier">
Parameters
- obj: object
Returns obj is Typed<"solutionModifier">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSolutionModifier
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:19

isSolutionModifierGroup

isSolutionModifierGroup(
obj: object,
): obj is SubTyped<"solutionModifier", "group">
Parameters
- obj: object
Returns obj is SubTyped<"solutionModifier", "group">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSolutionModifierGroup
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:77

isSolutionModifierHaving

isSolutionModifierHaving(
obj: object,
): obj is SubTyped<"solutionModifier", "having">
Parameters
- obj: object
Returns obj is SubTyped<"solutionModifier", "having">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSolutionModifierHaving
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:32

isSolutionModifierLimitOffset

isSolutionModifierLimitOffset(
obj: object,
): obj is SubTyped<"solutionModifier", "limitOffset">
Parameters
- obj: object
Returns obj is SubTyped<"solutionModifier", "limitOffset">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSolutionModifierLimitOffset
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:63

isSolutionModifierOrder

isSolutionModifierOrder(
obj: object,
): obj is SubTyped<"solutionModifier", "order">
Parameters
- obj: object
Returns obj is SubTyped<"solutionModifier", "order">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSolutionModifierOrder
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:45

isSourceLocation

isSourceLocation(loc: object): loc is SourceLocation
Parameters
- loc: object
Returns loc is SourceLocation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocation
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:23

isSourceLocationInlinedSource

isSourceLocationInlinedSource(loc: object): loc is SourceLocationInlinedSource
Parameters
- loc: object
Returns loc is SourceLocationInlinedSource
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationInlinedSource
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:29

isSourceLocationNodeAutoGenerate

isSourceLocationNodeAutoGenerate(
loc: object,
): loc is SourceLocationNodeAutoGenerate
Parameters
- loc: object
Returns loc is SourceLocationNodeAutoGenerate
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationNodeAutoGenerate
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:38

isSourceLocationNodeReplace

isSourceLocationNodeReplace(loc: object): loc is SourceLocationNodeReplace
Parameters
- loc: object
Returns loc is SourceLocationNodeReplace
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationNodeReplace
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:37

isSourceLocationNoMaterialize

isSourceLocationNoMaterialize(loc: object): loc is SourceLocationNoMaterialize
Parameters
- loc: object
Returns loc is SourceLocationNoMaterialize
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationNoMaterialize
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:41

isSourceLocationSource

isSourceLocationSource(loc: object): loc is SourceLocationSource
Parameters
- loc: object
Returns loc is SourceLocationSource
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationSource
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:31

isSourceLocationStringReplace

isSourceLocationStringReplace(loc: object): loc is SourceLocationStringReplace
Parameters
- loc: object
Returns loc is SourceLocationStringReplace
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isSourceLocationStringReplace
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:33

isTerm

isTerm(x: object): x is Typed<"term">
Parameters
- x: object
Returns x is Typed<"term">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTerm
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:27

isTermBlank

isTermBlank(obj: object): obj is SubTyped<"term", "blankNode">
Parameters
- obj: object
Returns obj is SubTyped<"term", "blankNode">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermBlank
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:43

isTermLiteral

isTermLiteral(obj: object): obj is SubTyped<"term", "literal">
Parameters
- obj: object
Returns obj is SubTyped<"term", "literal">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermLiteral
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:70

isTermLiteralLangStr

isTermLiteralLangStr(
obj: object,
): obj is SubTyped<"term", "literal"> & { langOrIri: string }
Parameters
- obj: object
Returns obj is SubTyped<"term", "literal"> & { langOrIri: string }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermLiteralLangStr
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:74

isTermLiteralStr

isTermLiteralStr(
obj: object,
): obj is SubTyped<"term", "literal"> & { langOrIri: undefined }
Parameters
- obj: object
Returns obj is SubTyped<"term", "literal"> & { langOrIri: undefined }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermLiteralStr
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:78

isTermLiteralTyped

isTermLiteralTyped(
obj: object,
): obj is SubTyped<"term", "literal"> & {
langOrIri: SubTyped<"term", "namedNode">;
}
Parameters
- obj: object
Returns obj is SubTyped<"term", "literal"> & {
langOrIri: SubTyped<"term", "namedNode">;
}
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermLiteralTyped
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:82

isTermNamed

isTermNamed(obj: object): obj is SubTyped<"term", "namedNode">
Parameters
- obj: object
Returns obj is SubTyped<"term", "namedNode">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermNamed
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:123

isTermNamedPrefixed

isTermNamedPrefixed(
obj: object,
): obj is SubTyped<"term", "namedNode"> & { prefix: string }
Parameters
- obj: object
Returns obj is SubTyped<"term", "namedNode"> & { prefix: string }
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermNamedPrefixed
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:127

isTermVariable

isTermVariable(obj: object): obj is SubTyped<"term", "variable">
Parameters
- obj: object
Returns obj is SubTyped<"term", "variable">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isTermVariable
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:98

isTriple

isTriple(obj: object): obj is Typed<"triple">
Parameters
- obj: object
Returns obj is Typed<"triple">
- Defined in rules-sparql-1-1/lib/astFactory.ts:76

isTripleCollection

isTripleCollection(obj: object): obj is Typed<"tripleCollection">
Parameters
- obj: object
Returns obj is Typed<"tripleCollection">
- Defined in rules-sparql-1-1/lib/astFactory.ts:100

isTripleCollectionBlankNodeProperties

isTripleCollectionBlankNodeProperties(
obj: object,
): obj is SubTyped<"tripleCollection", "blankNodeProperties">
Parameters
- obj: object
Returns obj is SubTyped<"tripleCollection", "blankNodeProperties">
- Defined in rules-sparql-1-1/lib/astFactory.ts:118

isTripleCollectionList

isTripleCollectionList(obj: object): obj is SubTyped<"tripleCollection", "list">
Parameters
- obj: object
Returns obj is SubTyped<"tripleCollection", "list">
- Defined in rules-sparql-1-1/lib/astFactory.ts:137

isUpdate

isUpdate(obj: object): obj is Update
Parameters
- obj: object
Returns obj is Update
- Defined in rules-sparql-1-1/lib/astFactory.ts:155

isUpdateOperation

isUpdateOperation(obj: object): obj is Typed<"updateOperation">
Parameters
- obj: object
Returns obj is Typed<"updateOperation">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperation
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:30

isUpdateOperationAdd

isUpdateOperationAdd(obj: object): obj is SubTyped<"updateOperation", "add">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "add">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationAdd
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:175

isUpdateOperationClear

isUpdateOperationClear(obj: object): obj is SubTyped<"updateOperation", "clear">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "clear">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationClear
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:87

isUpdateOperationCopy

isUpdateOperationCopy(obj: object): obj is SubTyped<"updateOperation", "copy">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "copy">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:201

isUpdateOperationCreate

isUpdateOperationCreate(
obj: object,
): obj is SubTyped<"updateOperation", "create">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "create">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationCreate
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:117

isUpdateOperationDeleteData

isUpdateOperationDeleteData(
obj: object,
): obj is SubTyped<"updateOperation", "deletedata">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "deletedata">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationDeleteData
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:241

isUpdateOperationDeleteWhere

isUpdateOperationDeleteWhere(
obj: object,
): obj is SubTyped<"updateOperation", "deletewhere">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "deletewhere">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationDeleteWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:249

isUpdateOperationDrop

isUpdateOperationDrop(obj: object): obj is SubTyped<"updateOperation", "drop">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "drop">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationDrop
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:99

isUpdateOperationInsertData

isUpdateOperationInsertData(
obj: object,
): obj is SubTyped<"updateOperation", "insertdata">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "insertdata">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationInsertData
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:233

isUpdateOperationLoad

isUpdateOperationLoad(obj: object): obj is SubTyped<"updateOperation", "load">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "load">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationLoad
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:50

isUpdateOperationModify

isUpdateOperationModify(
obj: object,
): obj is SubTyped<"updateOperation", "modify">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "modify">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationModify
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:273

isUpdateOperationMove

isUpdateOperationMove(obj: object): obj is SubTyped<"updateOperation", "move">
Parameters
- obj: object
Returns obj is SubTyped<"updateOperation", "move">
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().isUpdateOperationMove
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:188

isWildcard

isWildcard(obj: object): obj is Typed<"wildcard">
Parameters
- obj: object
Returns obj is Typed<"wildcard">
- Defined in rules-sparql-1-1/lib/astFactory.ts:96

path

path(
    subType: "|",
    items: (TermIri | PathNegatedElt)[],
    loc: SourceLocation,
): PathAlternativeLimited
Parameters
- subType: "|"
- items: (TermIri | PathNegatedElt)[]
- loc: SourceLocation
Returns PathAlternativeLimited
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().path
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:25
path(
    subType: "!",
    items: [TermIri | PathNegatedElt | PathAlternativeLimited],
    loc: SourceLocation,
): PathNegated
Parameters
- subType: "!"
- items: [TermIri | PathNegatedElt | PathAlternativeLimited]
- loc: SourceLocation
Returns PathNegated
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().path
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:30
path(subType: "^", items: [TermIri], loc: SourceLocation): PathNegatedElt
Parameters
- subType: "^"
- items: [TermIri]
- loc: SourceLocation
Returns PathNegatedElt
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().path
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:35
path(
    subType: "?" | "*" | "+" | "^",
    item: [Path],
    loc: SourceLocation,
): PathModified
Parameters
- subType: "?" | "*" | "+" | "^"
- item: [Path]
- loc: SourceLocation
Returns PathModified
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().path
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:36
path(subType: "|" | "/", items: Path[], loc: SourceLocation): PropertyPathChain
Parameters
- subType: "|" | "/"
- items: Path[]
- loc: SourceLocation
Returns PropertyPathChain
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().path
- Defined in rules-sparql-1-1/lib/factoryMixins/PathFactory.ts:37

patternBgp

patternBgp(triples: BasicGraphPattern, loc: SourceLocation): PatternBgp
Parameters
- triples: BasicGraphPattern
- loc: SourceLocation
Returns PatternBgp
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternBgp
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:32

patternBind

patternBind(
    expression: Expression,
    variable: TermVariable,
    loc: SourceLocation,
): PatternBind
Parameters
- expression: Expression
- variable: TermVariable
- loc: SourceLocation
Returns PatternBind
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternBind
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:85

patternFilter

patternFilter(expression: Expression, loc: SourceLocation): PatternFilter
Parameters
- expression: Expression
- loc: SourceLocation
Returns PatternFilter
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternFilter
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:72

patternGraph

patternGraph(
    name: TermIri | TermVariable,
    patterns: Pattern[],
    loc: SourceLocation,
): PatternGraph
Parameters
- name: TermIri | TermVariable
- patterns: Pattern[]
- loc: SourceLocation
Returns PatternGraph
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternGraph
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:48

patternGroup

patternGroup(patterns: Pattern[], loc: SourceLocation): PatternGroup
Parameters
- patterns: Pattern[]
- loc: SourceLocation
Returns PatternGroup
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternGroup
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:40

patternMinus

patternMinus(patterns: Pattern[], loc: SourceLocation): PatternMinus
Parameters
- patterns: Pattern[]
- loc: SourceLocation
Returns PatternMinus
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternMinus
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:116

patternOptional

patternOptional(patterns: Pattern[], loc: SourceLocation): PatternOptional
Parameters
- patterns: Pattern[]
- loc: SourceLocation
Returns PatternOptional
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternOptional
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:56

patternService

patternService(
    name: TermIri | TermVariable,
    patterns: Pattern[],
    silent: boolean,
    loc: SourceLocation,
): PatternService
Parameters
- name: TermIri | TermVariable
- patterns: Pattern[]
- silent: boolean
- loc: SourceLocation
Returns PatternService
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternService
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:129

patternUnion

patternUnion(patterns: PatternGroup[], loc: SourceLocation): PatternUnion
Parameters
- patterns: PatternGroup[]
- loc: SourceLocation
Returns PatternUnion
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternUnion
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:103

patternValues

patternValues(
    variables: TermVariable[],
    values: ValuePatternRow[],
    loc: SourceLocation,
): PatternValues
Parameters
- variables: TermVariable[]
- values: ValuePatternRow[]
- loc: SourceLocation
Returns PatternValues
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().patternValues
- Defined in rules-sparql-1-1/lib/factoryMixins/Patternfactory.ts:64

printFilter

printFilter(node: Localized, callback: () => void): void
Parameters
- node: Localized
- callback: () => void
Returns void
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().printFilter
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:40

queryConstruct

queryConstruct(
    loc: SourceLocation,
    context: ContextDefinition[],
    template: PatternBgp,
    where: PatternGroup,
    solutionModifiers: SolutionModifiers,
    datasets: DatasetClauses,
    values?: PatternValues,
): QueryConstruct
Parameters
- loc: SourceLocation
- context: ContextDefinition[]
- template: PatternBgp
- where: PatternGroup
- solutionModifiers: SolutionModifiers
- datasets: DatasetClauses
- Optionalvalues: PatternValues
Returns QueryConstruct
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().queryConstruct
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:28

querySelect

querySelect(
arg: Omit<QuerySelect, "type" | "subType" | "loc">,
loc: SourceLocation,
): QuerySelect
Parameters
- arg: Omit<QuerySelect, "type" | "subType" | "loc">
- loc: SourceLocation
Returns QuerySelect
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().querySelect
- Defined in rules-sparql-1-1/lib/factoryMixins/QueryFactory.ts:62

resetBlankNodeCounter

resetBlankNodeCounter(): void
Returns void
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().resetBlankNodeCounter
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:23

safeObjectTransform

safeObjectTransform(value: unknown, mapper: (some: object) => any): any
Parameters
- value: unknown
- mapper: (some: object) => any
Returns any
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().safeObjectTransform
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:20

solutionModifierGroup

solutionModifierGroup(
groupings: (Expression | SolutionModifierGroupBind)[],
loc: SourceLocation,
): SolutionModifierGroup
Parameters
- groupings: (Expression | SolutionModifierGroupBind)[]
- loc: SourceLocation
Returns SolutionModifierGroup
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().solutionModifierGroup
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:67

solutionModifierHaving

solutionModifierHaving(
having: Expression[],
loc: SourceLocation,
): SolutionModifierHaving
Parameters
- having: Expression[]
- loc: SourceLocation
Returns SolutionModifierHaving
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().solutionModifierHaving
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:23

solutionModifierLimitOffset

solutionModifierLimitOffset(
    limit: undefined | number,
    offset: undefined | number,
    loc: SourceLocation,
): SolutionModifierLimitOffset
Parameters
- limit: undefined | number
- offset: undefined | number
- loc: SourceLocation
Returns SolutionModifierLimitOffset
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().solutionModifierLimitOffset
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:49

solutionModifierOrder

solutionModifierOrder(
orderDefs: Ordering[],
loc: SourceLocation,
): SolutionModifierOrder
Parameters
- orderDefs: Ordering[]
- loc: SourceLocation
Returns SolutionModifierOrder
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().solutionModifierOrder
- Defined in rules-sparql-1-1/lib/factoryMixins/SolutionModifiersFactory.ts:36

sourceLocation

sourceLocation(...elements: (undefined | IToken | Localized)[]): SourceLocation
Parameters
- ...elements: (undefined | IToken | Localized)[]
Returns SourceLocation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocation
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:14

sourceLocationInlinedSource

sourceLocationInlinedSource(
    newSource: string,
    subLoc: SourceLocation,
    start: number,
    end: number,
    startOnNew?: number,
    endOnNew?: number,
): SourceLocation
{@inheritDoc SourceLocationInlinedSource}
Parameters
- newSource: string
- subLoc: SourceLocation
- start: number
- end: number
- OptionalstartOnNew: number
- OptionalendOnNew: number
Returns SourceLocation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationInlinedSource
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:28

sourceLocationNodeReplace

sourceLocationNodeReplace(
location: SourceLocationSource,
): SourceLocationNodeReplace
Parameters
- location: SourceLocationSource
Returns SourceLocationNodeReplace
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationNodeReplace
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:35
sourceLocationNodeReplace(start: number, end: number): SourceLocationNodeReplace
Parameters
- start: number
- end: number
Returns SourceLocationNodeReplace
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationNodeReplace
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:36

sourceLocationNodeReplaceUnsafe

sourceLocationNodeReplaceUnsafe(loc: SourceLocation): SourceLocationNodeReplace
Parameters
- loc: SourceLocation
Returns SourceLocationNodeReplace
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationNodeReplaceUnsafe
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:34

sourceLocationNoMaterialize

sourceLocationNoMaterialize(): SourceLocation
Returns SourceLocation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationNoMaterialize
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:15

sourceLocationSource

sourceLocationSource(start: number, end: number): SourceLocationSource
Parameters
- start: number
- end: number
Returns SourceLocationSource
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationSource
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:24

sourceLocationStringReplace

sourceLocationStringReplace(
    newSource: string,
    start: number,
    end: number,
): SourceLocation
Parameters
- newSource: string
- start: number
- end: number
Returns SourceLocation
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().sourceLocationStringReplace
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:32

termBlank

termBlank(label: undefined | string, loc: SourceLocation): TermBlank
Parameters
- label: undefined | string
- loc: SourceLocation
Returns TermBlank
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termBlank
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:31

termLiteral

termLiteral(
    loc: SourceLocation,
    value: string,
    lang?: undefined,
): TermLiteralStr
String, no lang, no type
Parameters
- loc: SourceLocation
- value: string
- Optionallang: undefined
Returns TermLiteralStr
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termLiteral
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:50
termLiteral(
    loc: SourceLocation,
    value: string,
    lang: string,
): TermLiteralLangStr
String with a language tag
Parameters
- loc: SourceLocation
- value: string
- lang: string
Returns TermLiteralLangStr
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termLiteral
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:54
termLiteral(loc: SourceLocation, value: string, iri: TermIri): TermLiteralTyped
Lexical form with a type
Parameters
- loc: SourceLocation
- value: string
- iri: TermIri
Returns TermLiteralTyped
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termLiteral
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:58
termLiteral(
    loc: SourceLocation,
    value: string,
    langOrIri?: string | TermIri,
): TermLiteral
String, no lang, no type
Parameters
- loc: SourceLocation
- value: string
- OptionallangOrIri: string | TermIri
Returns TermLiteral
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termLiteral
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:59

termNamed

termNamed(loc: SourceLocation, value: string, prefix?: undefined): TermIriFull
A namednode with fully defined with a uri.
Parameters
- loc: SourceLocation
- value: string
- Optionalprefix: undefined
Returns TermIriFull
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termNamed
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:105
termNamed(loc: SourceLocation, value: string, prefix: string): TermIriPrefixed
A namednode defined using a prefix
Parameters
- loc: SourceLocation
- value: string
- prefix: string
Returns TermIriPrefixed
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termNamed
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:109

termVariable

termVariable(value: string, loc: SourceLocation): TermVariable
Parameters
- value: string
- loc: SourceLocation
Returns TermVariable
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().termVariable
- Defined in rules-sparql-1-1/lib/factoryMixins/TermFactory.ts:89

triple

triple(
    subject: GraphNode,
    predicate:
        | TermIriFull
        | TermIriPrefixed
        | TermVariable
        | PropertyPathChain
        | PathModified
        | PathNegated,
    object: GraphNode,
    loc?: SourceLocation,
): TripleNesting
Parameters
- subject: GraphNode
- predicate:
      | TermIriFull
      | TermIriPrefixed
      | TermVariable
      | PropertyPathChain
      | PathModified
      | PathNegated
- object: GraphNode
- Optionalloc: SourceLocation
Returns TripleNesting
- Defined in rules-sparql-1-1/lib/astFactory.ts:61

tripleCollectionBlankNodeProperties

tripleCollectionBlankNodeProperties(
    identifier: TermBlank,
    triples: TripleNesting[],
    loc: SourceLocation,
): TripleCollectionBlankNodeProperties
Parameters
- identifier: TermBlank
- triples: TripleNesting[]
- loc: SourceLocation
Returns TripleCollectionBlankNodeProperties
- Defined in rules-sparql-1-1/lib/astFactory.ts:104

tripleCollectionList

tripleCollectionList(
    identifier: TermBlank,
    triples: TripleNesting[],
    loc: SourceLocation,
): TripleCollectionList
Parameters
- identifier: TermBlank
- triples: TripleNesting[]
- loc: SourceLocation
Returns TripleCollectionList
- Defined in rules-sparql-1-1/lib/astFactory.ts:123

updateOperationAdd

updateOperationAdd(
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationAdd
Parameters
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationAdd
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationAdd
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:166

updateOperationAddMoveCopy

updateOperationAddMoveCopy(
    subType: "add",
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationAdd
Parameters
- subType: "add"
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationAdd
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationAddMoveCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:121
updateOperationAddMoveCopy(
    subType: "move",
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationMove
Parameters
- subType: "move"
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationMove
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationAddMoveCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:128
updateOperationAddMoveCopy(
    subType: "copy",
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationCopy
Parameters
- subType: "copy"
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationCopy
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationAddMoveCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:135
updateOperationAddMoveCopy(
    subType: "add" | "copy" | "move",
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy
Parameters
- subType: "add" | "copy" | "move"
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationAdd | UpdateOperationMove | UpdateOperationCopy
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationAddMoveCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:142

updateOperationClear

updateOperationClear(
    destination: GraphRef,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationClear
Parameters
- destination: GraphRef
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationClear
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationClear
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:79

updateOperationClearDrop

updateOperationClearDrop(
    subType: "clear",
    silent: boolean,
    destination: GraphRef,
    loc: SourceLocation,
): UpdateOperationClear
Parameters
- subType: "clear"
- silent: boolean
- destination: GraphRef
- loc: SourceLocation
Returns UpdateOperationClear
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationClearDrop
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:54
updateOperationClearDrop(
    subType: "drop",
    silent: boolean,
    destination: GraphRef,
    loc: SourceLocation,
): UpdateOperationDrop
Parameters
- subType: "drop"
- silent: boolean
- destination: GraphRef
- loc: SourceLocation
Returns UpdateOperationDrop
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationClearDrop
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:56
updateOperationClearDrop(
    subType: "clear" | "drop",
    silent: boolean,
    destination: GraphRef,
    loc: SourceLocation,
): UpdateOperationClear | UpdateOperationDrop
Parameters
- subType: "clear" | "drop"
- silent: boolean
- destination: GraphRef
- loc: SourceLocation
Returns UpdateOperationClear | UpdateOperationDrop
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationClearDrop
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:58

updateOperationCopy

updateOperationCopy(
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationCopy
Parameters
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationCopy
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationCopy
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:192

updateOperationCreate

updateOperationCreate(
    destination: GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationCreate
Parameters
- destination: GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationCreate
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationCreate
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:103

updateOperationDeleteData

updateOperationDeleteData(
data: Quads[],
loc: SourceLocation,
): UpdateOperationDeleteData
Parameters
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationDeleteData
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationDeleteData
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:237

updateOperationDeleteWhere

updateOperationDeleteWhere(
data: Quads[],
loc: SourceLocation,
): UpdateOperationDeleteWhere
Parameters
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationDeleteWhere
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationDeleteWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:245

updateOperationDrop

updateOperationDrop(
    destination: GraphRef,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationDrop
Parameters
- destination: GraphRef
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationDrop
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationDrop
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:91

updateOperationInsDelDataWhere

updateOperationInsDelDataWhere(
    subType: "insertdata",
    data: Quads[],
    loc: SourceLocation,
): UpdateOperationInsertData
Parameters
- subType: "insertdata"
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationInsertData
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationInsDelDataWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:205
updateOperationInsDelDataWhere(
    subType: "deletedata",
    data: Quads[],
    loc: SourceLocation,
): UpdateOperationDeleteData
Parameters
- subType: "deletedata"
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationDeleteData
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationInsDelDataWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:207
updateOperationInsDelDataWhere(
    subType: "deletewhere",
    data: Quads[],
    loc: SourceLocation,
): UpdateOperationDeleteWhere
Parameters
- subType: "deletewhere"
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationDeleteWhere
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationInsDelDataWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:209
updateOperationInsDelDataWhere(
    subType: "insertdata" | "deletedata" | "deletewhere",
    data: Quads[],
    loc: SourceLocation,
):
    | UpdateOperationInsertData
    | UpdateOperationDeleteData
    | UpdateOperationDeleteWhere
Parameters
- subType: "insertdata" | "deletedata" | "deletewhere"
- data: Quads[]
- loc: SourceLocation
Returns
    | UpdateOperationInsertData
    | UpdateOperationDeleteData
    | UpdateOperationDeleteWhere
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationInsDelDataWhere
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:211

updateOperationInsertData

updateOperationInsertData(
data: Quads[],
loc: SourceLocation,
): UpdateOperationInsertData
Parameters
- data: Quads[]
- loc: SourceLocation
Returns UpdateOperationInsertData
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationInsertData
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:229

updateOperationLoad

updateOperationLoad(
    loc: SourceLocation,
    source: TermIri,
    silent: boolean,
    destination?: GraphRefSpecific,
): UpdateOperationLoad
Parameters
- loc: SourceLocation
- source: TermIri
- silent: boolean
- Optionaldestination: GraphRefSpecific
Returns UpdateOperationLoad
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationLoad
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:34

updateOperationModify

updateOperationModify(
    loc: SourceLocation,
    insert: undefined | Quads[],
    del: undefined | Quads[],
    where: PatternGroup,
    from: DatasetClauses,
    graph?: TermIri,
): UpdateOperationModify
Parameters
- loc: SourceLocation
- insert: undefined | Quads[]
- del: undefined | Quads[]
- where: PatternGroup
- from: DatasetClauses
- Optionalgraph: TermIri
Returns UpdateOperationModify
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationModify
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:253

updateOperationMove

updateOperationMove(
    source: GraphRefDefault | GraphRefSpecific,
    destination: GraphRefDefault | GraphRefSpecific,
    silent: boolean,
    loc: SourceLocation,
): UpdateOperationMove
Parameters
- source: GraphRefDefault | GraphRefSpecific
- destination: GraphRefDefault | GraphRefSpecific
- silent: boolean
- loc: SourceLocation
Returns UpdateOperationMove
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().updateOperationMove
- Defined in rules-sparql-1-1/lib/factoryMixins/UpdateOperationFactory.ts:179

wildcard

wildcard(loc: SourceLocation): Wildcard
Parameters
- loc: SourceLocation
Returns Wildcard
- Defined in rules-sparql-1-1/lib/astFactory.ts:92

wrap

wrap<T>(val: T, loc: SourceLocation): Wrap<T>
Type Parameters
- T
Parameters
- val: T
- loc: SourceLocation
Returns Wrap<T>
Inherited from asArg(AstCoreFactory) .call(ContextFactoryMixin) .call(ExpressionFactoryMixin) .call(GraphRefFactoryMixin) .call(PathFactoryMixin) .call(PatternFactoryMixin) .call(QueryFactoryMixin) .call(SolutionModifiersFactoryMixin) .call(TermFactoryMixin) .call(UpdateOperationFactoryMixin) .returns().wrap
- Defined in core/dist/esm/lib/AstCoreFactory.d.ts:12

Class AstFactory

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns AstFactory

Properties

__blankNodeCounter

tracksSourceLocation

Methods

aggregate

Parameters

Returns ExpressionAggregateDefault

Parameters

Returns ExpressionAggregateOnWildcard

Parameters

Returns ExpressionAggregateSeparator

Parameters

Returns ExpressionAggregate

alwaysSparql11

Parameters

Returns obj is Sparql11Nodes

contextDefinitionBase

Parameters

Returns ContextDefinitionBase

contextDefinitionPrefix

Parameters

Returns ContextDefinitionPrefix

datasetClauses

Parameters

Returns DatasetClauses

dematerialized

Type Parameters

Parameters

Returns T

expressionFunctionCall

Type Parameters

Parameters

Returns Node & { subType: string; type: "expression" } & { args: Expression[]; distinct: boolean; function: TermIri; subType: "functionCall";} & { args: Args }

expressionOperation

Type Parameters

Parameters

Returns Node & { subType: string; type: "expression" } & { args: Expression[]; operator: string; subType: "operation";} & { args: Args }

expressionPatternOperation

Parameters

Returns ExpressionPatternOperation

forcedAutoGenTree

Type Parameters

Parameters

Returns T

forceMaterialized

Type Parameters

Parameters

Returns T

formatOperator

Parameters

Returns string

gen

Returns SourceLocationNodeAutoGenerate

graphNodeIdentifier

Parameters

Returns Term

graphQuads

Parameters

Returns GraphQuads

graphRefAll

Parameters

Returns GraphRefAll

graphRefDefault

Parameters

Returns GraphRefDefault

graphRefNamed

Parameters

Returns GraphRefNamed

graphRefSpecific

Parameters

Returns Node & { subType: string; type: "expression" } & {
args: Expression[];
distinct: boolean;
function: TermIri;
subType: "functionCall";
} & { args: Args }

Returns Node & { subType: string; type: "expression" } & {
args: Expression[];
operator: string;
subType: "operation";
} & { args: Args }

Returns obj is
| Typed<"expression">
| SubTyped<"term", "variable" | "literal" | "namedNode">