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>,
            [],
        >;
    },
> = ...