Traqula
    Preparing search index...

    Variable sparql12GeneratorBuilderConst

    sparql12GeneratorBuilder: GeneratorBuilder<
        SparqlGeneratorContext,
        | "filter"
        | "add"
        | "clear"
        | "copy"
        | "move"
        | "var"
        | "path"
        | "drop"
        | "load"
        | "update"
        | "graphRef"
        | "create"
        | "modify"
        | "query"
        | "datasetClauses"
        | "bind"
        | "solutionModifier"
        | "expression"
        | "aggregate"
        | "blankNode"
        | "selectQuery"
        | "selectClause"
        | "constructQuery"
        | "describeQuery"
        | "askQuery"
        | "update1"
        | "insertData"
        | "deleteData"
        | "deleteWhere"
        | "graphRefAll"
        | "quads"
        | "quadsNotTriples"
        | "usingClauses"
        | "argList"
        | "iriOrFunction"
        | "prologue"
        | "baseDecl"
        | "prefixDecl"
        | "varOrTerm"
        | "graphTerm"
        | "rdfLiteral"
        | "iri"
        | "iriFull"
        | "prefixedName"
        | "groupClause"
        | "havingClause"
        | "orderClause"
        | "limitOffsetClauses"
        | "triplesBlock"
        | "collectionPath"
        | "triplesNodePath"
        | "blankNodePropertyListPath"
        | "graphNodePath"
        | "whereClause"
        | "groupGraphPattern"
        | "generatePattern"
        | "graphPatternNotTriples"
        | "optionalGraphPattern"
        | "graphGraphPattern"
        | "serviceGraphPattern"
        | "inlineData"
        | "minusGraphPattern"
        | "groupOrUnionGraphPattern"
        | "queryOrUpdate"
        | "reifiedTriple"
        | "versionDecl"
        | "annotationPath"
        | "annotationBlockPath"
        | "tripleTerm",
        {
            add: GeneratorRule<
                SparqlGeneratorContext,
                "add",
                UpdateOperationAdd,
                [],
            >;
            aggregate: GeneratorRule<
                SparqlGeneratorContext,
                "aggregate",
                ExpressionAggregate,
                [],
            >;
            annotationBlockPath: GeneratorRule<
                SparqlGeneratorContext,
                "annotationBlockPath",
                Patch<
                    TripleCollectionBlankNodeProperties,
                    {
                        identifier: TermIri
                        | TermVariable
                        | TermBlank;
                        triples: TripleNesting[];
                    },
                >,
                [],
            >;
            annotationPath: GeneratorRule<
                SparqlGeneratorContext,
                "annotationPath",
                Annotation[],
                [],
            >;
            argList: GeneratorRule<
                SparqlGeneratorContext,
                "argList",
                Patch<IArgList, { args: Expression[] }>,
                [],
            >;
            askQuery: GeneratorRule<
                SparqlGeneratorContext,
                "askQuery",
                Omit<QueryAsk, HandledByBase>,
                [],
            >;
            baseDecl: GeneratorRule<
                SparqlGeneratorContext,
                "baseDecl",
                ContextDefinitionBase,
                [],
            >;
            bind: GeneratorRule<SparqlGeneratorContext, "bind", PatternBind, []>;
            blankNode: GeneratorRule<
                SparqlGeneratorContext,
                "blankNode",
                Node & { subType: string; type: "term" } & { subType: "blankNode" } & {
                    label: string;
                },
                [],
            >;
            blankNodePropertyListPath: GeneratorRule<
                SparqlGeneratorContext,
                "blankNodePropertyListPath",
                Patch<
                    TripleCollectionBlankNodeProperties,
                    {
                        identifier: TermIri
                        | TermVariable
                        | TermBlank;
                        triples: TripleNesting[];
                    },
                >,
                [],
            >;
            clear: GeneratorRule<
                SparqlGeneratorContext,
                "clear",
                UpdateOperationClear,
                [],
            >;
            collectionPath: GeneratorRule<
                SparqlGeneratorContext,
                "collectionPath",
                TripleCollectionList,
                [],
            >;
            constructQuery: GeneratorRule<
                SparqlGeneratorContext,
                "constructQuery",
                Omit<QueryConstruct, HandledByBase>,
                [],
            >;
            copy: GeneratorRule<
                SparqlGeneratorContext,
                "copy",
                UpdateOperationCopy,
                [],
            >;
            create: GeneratorRule<
                SparqlGeneratorContext,
                "create",
                UpdateOperationCreate,
                [],
            >;
            datasetClauses: GeneratorRule<
                SparqlGeneratorContext,
                "datasetClauses",
                DatasetClauses,
                [],
            >;
            deleteData: GeneratorRule<
                SparqlGeneratorContext,
                "deleteData",
                UpdateOperationDeleteData,
                [],
            >;
            deleteWhere: GeneratorRule<
                SparqlGeneratorContext,
                "deleteWhere",
                UpdateOperationDeleteWhere,
                [],
            >;
            describeQuery: GeneratorRule<
                SparqlGeneratorContext,
                "describeQuery",
                Omit<QueryDescribe, HandledByBase>,
                [],
            >;
            drop: GeneratorRule<
                SparqlGeneratorContext,
                "drop",
                UpdateOperationDrop,
                [],
            >;
            expression: GeneratorRule<
                SparqlGeneratorContext,
                "expression",
                Expression,
                [],
            >;
            filter: GeneratorRule<SparqlGeneratorContext, "filter", PatternFilter, []>;
            generatePattern: GeneratorRule<
                SparqlGeneratorContext,
                "generatePattern",
                Pattern,
                [],
            >;
            graphGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "graphGraphPattern",
                PatternGroup,
                [],
            >;
            graphNodePath: GeneratorRule<
                SparqlGeneratorContext,
                "graphNodePath",
                GraphNode,
                [],
            >;
            graphPatternNotTriples: GeneratorRule<
                SparqlGeneratorContext,
                "graphPatternNotTriples",
                | PatternGroup
                | PatternUnion
                | PatternOptional
                | PatternMinus
                | PatternGraph
                | PatternService
                | PatternFilter
                | PatternBind
                | PatternValues,
                [],
            >;
            graphRef: GeneratorRule<SparqlGeneratorContext, "graphRef", TermIri, []>;
            graphRefAll: GeneratorRule<
                SparqlGeneratorContext,
                "graphRefAll",
                GraphRef,
                [],
            >;
            graphTerm: GeneratorRule<
                SparqlGeneratorContext,
                "graphTerm",
                GraphTerm,
                [],
            >;
            groupClause: GeneratorRule<
                SparqlGeneratorContext,
                "groupClause",
                SolutionModifierGroup,
                [],
            >;
            groupGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "groupGraphPattern",
                PatternGroup,
                [],
            >;
            groupOrUnionGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "groupOrUnionGraphPattern",
                PatternGroup
                | PatternUnion,
                [],
            >;
            havingClause: GeneratorRule<
                SparqlGeneratorContext,
                "havingClause",
                SolutionModifierHaving,
                [],
            >;
            inlineData: GeneratorRule<
                SparqlGeneratorContext,
                "inlineData",
                PatternValues,
                [],
            >;
            insertData: GeneratorRule<
                SparqlGeneratorContext,
                "insertData",
                UpdateOperationInsertData,
                [],
            >;
            iri: GeneratorRule<SparqlGeneratorContext, "iri", TermIri, []>;
            iriFull: GeneratorRule<
                SparqlGeneratorContext,
                "iriFull",
                Node & { subType: string; type: "term" } & { subType: "namedNode" } & {
                    value: string;
                },
                [],
            >;
            iriOrFunction: GeneratorRule<
                SparqlGeneratorContext,
                "iriOrFunction",
                TermIri
                | ExpressionFunctionCall,
                [],
            >;
            limitOffsetClauses: GeneratorRule<
                SparqlGeneratorContext,
                "limitOffsetClauses",
                SolutionModifierLimitOffset,
                [],
            >;
            load: GeneratorRule<
                SparqlGeneratorContext,
                "load",
                UpdateOperationLoad,
                [],
            >;
            minusGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "minusGraphPattern",
                PatternMinus,
                [],
            >;
            modify: GeneratorRule<
                SparqlGeneratorContext,
                "modify",
                UpdateOperationModify,
                [],
            >;
            move: GeneratorRule<
                SparqlGeneratorContext,
                "move",
                UpdateOperationMove,
                [],
            >;
            optionalGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "optionalGraphPattern",
                PatternOptional,
                [],
            >;
            orderClause: GeneratorRule<
                SparqlGeneratorContext,
                "orderClause",
                SolutionModifierOrder,
                [],
            >;
            path: GeneratorRule<
                SparqlGeneratorContext,
                "path",
                Path,
                [undefined | boolean],
            >;
            prefixDecl: GeneratorRule<
                SparqlGeneratorContext,
                "prefixDecl",
                ContextDefinitionPrefix,
                [],
            >;
            prefixedName: GeneratorRule<
                SparqlGeneratorContext,
                "prefixedName",
                Node & { subType: string; type: "term" } & { subType: "namedNode" } & {
                    prefix: string;
                    value: string;
                },
                [],
            >;
            prologue: GeneratorRule<
                SparqlGeneratorContext,
                "prologue",
                ContextDefinition[],
                [],
            >;
            quads: GeneratorRule<SparqlGeneratorContext, "quads", Wrap<Quads[]>, []>;
            quadsNotTriples: GeneratorRule<
                SparqlGeneratorContext,
                "quadsNotTriples",
                GraphQuads,
                [],
            >;
            query: GeneratorRule<SparqlGeneratorContext, "query", Query, []>;
            queryOrUpdate: GeneratorRule<
                SparqlGeneratorContext,
                "queryOrUpdate",
                SparqlQuery,
                [],
            >;
            rdfLiteral: GeneratorRule<
                SparqlGeneratorContext,
                "rdfLiteral",
                TermLiteral,
                [],
            >;
            reifiedTriple: GeneratorRule<
                SparqlGeneratorContext,
                "reifiedTriple",
                TripleCollectionReifiedTriple,
                [],
            >;
            selectClause: GeneratorRule<
                SparqlGeneratorContext,
                "selectClause",
                Wrap<Pick<QuerySelect, "variables" | "distinct" | "reduced">>,
                [],
            >;
            selectQuery: GeneratorRule<
                SparqlGeneratorContext,
                "selectQuery",
                Omit<QuerySelect, HandledByBase>,
                [],
            >;
            serviceGraphPattern: GeneratorRule<
                SparqlGeneratorContext,
                "serviceGraphPattern",
                PatternService,
                [],
            >;
            solutionModifier: GeneratorRule<
                SparqlGeneratorContext,
                "solutionModifier",
                SolutionModifiers,
                [],
            >;
            triplesBlock: GeneratorRule<
                SparqlGeneratorContext,
                "triplesBlock",
                PatternBgp,
                [],
            >;
            triplesNodePath: GeneratorRule<
                SparqlGeneratorContext,
                "triplesNodePath",
                TripleCollection,
                [],
            >;
            tripleTerm: GeneratorRule<
                SparqlGeneratorContext,
                "tripleTerm",
                TermTriple,
                [],
            >;
            update: GeneratorRule<SparqlGeneratorContext, "update", Update, []>;
            update1: GeneratorRule<
                SparqlGeneratorContext,
                "update1",
                UpdateOperation,
                [],
            >;
            usingClauses: GeneratorRule<
                SparqlGeneratorContext,
                "usingClauses",
                DatasetClauses,
                [],
            >;
            var: GeneratorRule<
                SparqlGeneratorContext,
                "var",
                Node & { subType: string; type: "term" } & {
                    subType: "variable";
                    value: string;
                },
                [],
            >;
            varOrTerm: GeneratorRule<SparqlGeneratorContext, "varOrTerm", Term, []>;
            versionDecl: GeneratorRule<
                SparqlGeneratorContext,
                "versionDecl",
                ContextDefinitionVersion,
                [],
            >;
            whereClause: GeneratorRule<
                SparqlGeneratorContext,
                "whereClause",
                Wrap<PatternGroup>,
                [],
            >;
        },
    > = ...