Variable sparql11GeneratorBuilderConst

sparql11GeneratorBuilder: GeneratorBuilder<
    undefined,
    | "string"
    | "filter"
    | "add"
    | "clear"
    | "copy"
    | "move"
    | "var"
    | "path"
    | "drop"
    | "load"
    | "update"
    | "query"
    | "quads"
    | "create"
    | "bind"
    | "aggregate"
    | "rdfLiteral"
    | "iri"
    | "blankNode"
    | "datasetClause"
    | "prologue"
    | "varOrTerm"
    | "graphTerm"
    | "triplesBlock"
    | "groupGraphPattern"
    | "graphPatternNotTriples"
    | "groupOrUnionGraphPattern"
    | "optionalGraphPattern"
    | "minusGraphPattern"
    | "graphGraphPattern"
    | "serviceGraphPattern"
    | "expression"
    | "valuesClause"
    | "inlineDataFull"
    | "dataBlockValue"
    | "argList"
    | "iriOrFunction"
    | "solutionModifier"
    | "limitOffsetClauses"
    | "groupClause"
    | "havingClause"
    | "orderClause"
    | "groupCondition"
    | "orderCondition"
    | "selectQuery"
    | "constructQuery"
    | "describeQuery"
    | "askQuery"
    | "selectClause"
    | "constructTemplate"
    | "update1"
    | "insertData"
    | "deleteData"
    | "deleteWhere"
    | "modify"
    | "graphRef"
    | "graphRefAll"
    | "graphOrDefault"
    | "quadData"
    | "quadsNotTriples",
    {
        add: GeneratorRule<any, "add"> & ParserRule<
            SparqlContext,
            "add",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "add", CopyMoveAddOperation, undefined>;
        aggregate: GeneratorRule<
            undefined,
            "aggregate",
            AggregateExpression,
            undefined,
        >;
        argList: GeneratorRule<any, "argList"> & ParserRule<
            SparqlContext,
            "argList",
            IArgList,
            undefined,
        > & GeneratorRule<undefined, "argList", IArgList, undefined>;
        askQuery: GeneratorRule<any, "askQuery"> & ParserRule<
            SparqlContext,
            "askQuery",
            Omit<AskQuery, HandledByBase>,
            undefined,
        > & GeneratorRule<
            undefined,
            "askQuery",
            Omit<AskQuery, HandledByBase>,
            undefined,
        >;
        bind: GeneratorRule<any, "bind"> & ParserRule<
            SparqlContext,
            "bind",
            BindPattern,
            undefined,
        > & GeneratorRule<undefined, "bind", BindPattern, undefined>;
        blankNode: GeneratorRule<any, "blankNode"> & ParserRule<
            SparqlContext,
            "blankNode",
            BlankNode,
            undefined,
        > & GeneratorRule<undefined, "blankNode", BlankNode, undefined>;
        clear: GeneratorRule<any, "clear"> & ParserRule<
            SparqlContext,
            "clear",
            ClearDropOperation,
            undefined,
        > & GeneratorRule<undefined, "clear", ClearDropOperation, undefined>;
        constructQuery: GeneratorRule<any, "constructQuery"> & ParserRule<
            SparqlContext,
            "constructQuery",
            Omit<ConstructQuery, HandledByBase>,
            undefined,
        > & GeneratorRule<
            undefined,
            "constructQuery",
            Omit<ConstructQuery, HandledByBase>,
            undefined,
        >;
        constructTemplate: GeneratorRule<any, "constructTemplate"> & ParserRule<
            SparqlContext,
            "constructTemplate",
            undefined
            | Triple[],
            undefined,
        > & GeneratorRule<
            undefined,
            "constructTemplate",
            undefined
            | Triple[],
            undefined,
        >;
        copy: GeneratorRule<any, "copy"> & ParserRule<
            SparqlContext,
            "copy",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "copy", CopyMoveAddOperation, undefined>;
        create: GeneratorRule<any, "create"> & ParserRule<
            SparqlContext,
            "create",
            CreateOperation,
            undefined,
        > & GeneratorRule<undefined, "create", CreateOperation, undefined>;
        dataBlockValue: GeneratorRule<any, "dataBlockValue"> & ParserRule<
            SparqlContext,
            "dataBlockValue",
            undefined
            | BlankNode
            | Literal
            | IriTerm,
            undefined,
        > & GeneratorRule<
            undefined,
            "dataBlockValue",
            undefined
            | BlankNode
            | Literal
            | IriTerm,
            undefined,
        >;
        datasetClause: GeneratorRule<
            undefined,
            "datasetClause",
            IDatasetClause,
            undefined,
        >;
        deleteData: GeneratorRule<any, "deleteData"> & ParserRule<
            SparqlContext,
            "deleteData",
            DeleteOperation,
            undefined,
        > & GeneratorRule<undefined, "deleteData", DeleteOperation, undefined>;
        deleteWhere: GeneratorRule<any, "deleteWhere"> & ParserRule<
            SparqlContext,
            "deleteWhere",
            DeleteWhereOperation,
            undefined,
        > & GeneratorRule<
            undefined,
            "deleteWhere",
            DeleteWhereOperation,
            undefined,
        >;
        describeQuery: GeneratorRule<any, "describeQuery"> & ParserRule<
            SparqlContext,
            "describeQuery",
            Omit<DescribeQuery, HandledByBase>,
            undefined,
        > & GeneratorRule<
            undefined,
            "describeQuery",
            Omit<DescribeQuery, HandledByBase>,
            undefined,
        >;
        drop: GeneratorRule<any, "drop"> & ParserRule<
            SparqlContext,
            "drop",
            ClearDropOperation,
            undefined,
        > & GeneratorRule<undefined, "drop", ClearDropOperation, undefined>;
        expression: GeneratorRule<any, "expression"> & ParserRule<
            SparqlContext,
            "expression",
            Expression,
            undefined,
        > & GeneratorRule<undefined, "expression", Expression, undefined>;
        filter: GeneratorRule<any, "filter"> & ParserRule<
            SparqlContext,
            "filter",
            FilterPattern,
            undefined,
        > & GeneratorRule<undefined, "filter", FilterPattern, undefined>;
        graphGraphPattern: GeneratorRule<any, "graphGraphPattern"> & ParserRule<
            SparqlContext,
            "graphGraphPattern",
            GraphPattern,
            undefined,
        > & GeneratorRule<undefined, "graphGraphPattern", GraphPattern, undefined>;
        graphOrDefault: GeneratorRule<any, "graphOrDefault"> & ParserRule<
            SparqlContext,
            "graphOrDefault",
            GraphOrDefault,
            undefined,
        > & GeneratorRule<undefined, "graphOrDefault", GraphOrDefault, undefined>;
        graphPatternNotTriples: GeneratorRule<any, "graphPatternNotTriples"> & ParserRule<
            SparqlContext,
            "graphPatternNotTriples",
            GraphPatternNotTriplesReturn,
            undefined,
        > & GeneratorRule<
            undefined,
            "graphPatternNotTriples",
            GraphPatternNotTriplesReturn,
            undefined,
        >;
        graphRef: GeneratorRule<any, "graphRef"> & ParserRule<
            SparqlContext,
            "graphRef",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "graphRef", IriTerm, undefined>;
        graphRefAll: GeneratorRule<any, "graphRefAll"> & ParserRule<
            SparqlContext,
            "graphRefAll",
            GraphReference,
            undefined,
        > & GeneratorRule<undefined, "graphRefAll", GraphReference, undefined>;
        graphTerm: GeneratorRule<any, "graphTerm"> & ParserRule<
            SparqlContext,
            "graphTerm",
            GraphTerm,
            undefined,
        > & GeneratorRule<undefined, "graphTerm", GraphTerm, undefined>;
        groupClause: GeneratorRule<any, "groupClause"> & ParserRule<
            SparqlContext,
            "groupClause",
            Grouping[],
            undefined,
        > & GeneratorRule<undefined, "groupClause", Grouping[], undefined>;
        groupCondition: GeneratorRule<any, "groupCondition"> & ParserRule<
            SparqlContext,
            "groupCondition",
            Grouping,
            undefined,
        > & GeneratorRule<undefined, "groupCondition", Grouping, undefined>;
        groupGraphPattern: GeneratorRule<any, "groupGraphPattern"> & ParserRule<
            SparqlContext,
            "groupGraphPattern",
            GroupPattern,
            undefined,
        > & GeneratorRule<undefined, "groupGraphPattern", GroupPattern, undefined>;
        groupOrUnionGraphPattern: GeneratorRule<any, "groupOrUnionGraphPattern"> & ParserRule<
            SparqlContext,
            "groupOrUnionGraphPattern",
            UnionPattern
            | GroupPattern,
            undefined,
        > & GeneratorRule<
            undefined,
            "groupOrUnionGraphPattern",
            UnionPattern
            | GroupPattern,
            undefined,
        >;
        havingClause: GeneratorRule<any, "havingClause"> & ParserRule<
            SparqlContext,
            "havingClause",
            Expression[],
            undefined,
        > & GeneratorRule<undefined, "havingClause", Expression[], undefined>;
        inlineDataFull: GeneratorRule<any, "inlineDataFull"> & ParserRule<
            SparqlContext,
            "inlineDataFull",
            ValuePatternRow[],
            undefined,
        > & GeneratorRule<
            undefined,
            "inlineDataFull",
            ValuePatternRow[],
            undefined,
        >;
        insertData: GeneratorRule<any, "insertData"> & ParserRule<
            SparqlContext,
            "insertData",
            InsertOperation,
            undefined,
        > & GeneratorRule<undefined, "insertData", InsertOperation, undefined>;
        iri: GeneratorRule<any, "iri"> & ParserRule<
            SparqlContext,
            "iri",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "iri", IriTerm, undefined>;
        iriOrFunction: GeneratorRule<any, "iriOrFunction"> & ParserRule<
            SparqlContext,
            "iriOrFunction",
            IriTerm
            | IArgList & { function: IriTerm },
            undefined,
        > & GeneratorRule<
            undefined,
            "iriOrFunction",
            IriTerm
            | IArgList & { function: IriTerm },
            undefined,
        >;
        limitOffsetClauses: GeneratorRule<any, "limitOffsetClauses"> & ParserRule<
            SparqlContext,
            "limitOffsetClauses",
            Pick<SelectQuery, "offset" | "limit">,
            undefined,
        > & GeneratorRule<
            undefined,
            "limitOffsetClauses",
            Pick<SelectQuery, "offset" | "limit">,
            undefined,
        >;
        load: GeneratorRule<any, "load"> & ParserRule<
            SparqlContext,
            "load",
            LoadOperation,
            undefined,
        > & GeneratorRule<undefined, "load", LoadOperation, undefined>;
        minusGraphPattern: GeneratorRule<any, "minusGraphPattern"> & ParserRule<
            SparqlContext,
            "minusGraphPattern",
            MinusPattern,
            undefined,
        > & GeneratorRule<undefined, "minusGraphPattern", MinusPattern, undefined>;
        modify: GeneratorRule<any, "modify"> & ParserRule<
            SparqlContext,
            "modify",
            ModifyOperation,
            undefined,
        > & GeneratorRule<undefined, "modify", ModifyOperation, undefined>;
        move: GeneratorRule<any, "move"> & ParserRule<
            SparqlContext,
            "move",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "move", CopyMoveAddOperation, undefined>;
        optionalGraphPattern: GeneratorRule<any, "optionalGraphPattern"> & ParserRule<
            SparqlContext,
            "optionalGraphPattern",
            OptionalPattern,
            undefined,
        > & GeneratorRule<
            undefined,
            "optionalGraphPattern",
            OptionalPattern,
            undefined,
        >;
        orderClause: GeneratorRule<any, "orderClause"> & ParserRule<
            SparqlContext,
            "orderClause",
            Ordering[],
            undefined,
        > & GeneratorRule<undefined, "orderClause", Ordering[], undefined>;
        orderCondition: GeneratorRule<any, "orderCondition"> & ParserRule<
            SparqlContext,
            "orderCondition",
            Ordering,
            undefined,
        > & GeneratorRule<undefined, "orderCondition", Ordering, undefined>;
        path: GeneratorRule<undefined, "path", PropertyPath | IriTerm, undefined>;
        prologue: GeneratorRule<any, "prologue"> & ParserRule<
            SparqlContext,
            "prologue",
            Pick<BaseQuery, "base" | "prefixes">,
            undefined,
        > & GeneratorRule<
            undefined,
            "prologue",
            Pick<BaseQuery, "base" | "prefixes">,
            undefined,
        >;
        quadData: GeneratorRule<any, "quadData"> & ParserRule<
            SparqlContext,
            "quadData",
            Quads[],
            undefined,
        > & GeneratorRule<undefined, "quadData", Quads[], undefined>;
        quads: GeneratorRule<any, "quads"> & ParserRule<
            SparqlContext,
            "quads",
            Quads[],
            undefined,
        > & GeneratorRule<undefined, "quads", Quads[], undefined>;
        quadsNotTriples: GeneratorRule<any, "quadsNotTriples"> & ParserRule<
            SparqlContext,
            "quadsNotTriples",
            GraphQuads,
            undefined,
        > & GeneratorRule<undefined, "quadsNotTriples", GraphQuads, undefined>;
        query: GeneratorRule<any, "query"> & ParserRule<
            SparqlContext,
            "query",
            Query,
            undefined,
        > & GeneratorRule<undefined, "query", Query, undefined>;
        rdfLiteral: GeneratorRule<any, "rdfLiteral"> & ParserRule<
            SparqlContext,
            "rdfLiteral",
            Literal,
            undefined,
        > & GeneratorRule<undefined, "rdfLiteral", Literal, undefined>;
        selectClause: GeneratorRule<any, "selectClause"> & ParserRule<
            SparqlContext,
            "selectClause",
            ISelectClause,
            undefined,
        > & GeneratorRule<undefined, "selectClause", ISelectClause, undefined>;
        selectQuery: GeneratorRule<any, "selectQuery"> & ParserRule<
            SparqlContext,
            "selectQuery",
            Omit<SelectQuery, HandledByBase>,
            undefined,
        > & GeneratorRule<
            undefined,
            "selectQuery",
            Omit<SelectQuery, HandledByBase>,
            undefined,
        >;
        serviceGraphPattern: GeneratorRule<any, "serviceGraphPattern"> & ParserRule<
            SparqlContext,
            "serviceGraphPattern",
            ServicePattern,
            undefined,
        > & GeneratorRule<
            undefined,
            "serviceGraphPattern",
            ServicePattern,
            undefined,
        >;
        solutionModifier: GeneratorRule<any, "solutionModifier"> & ParserRule<
            SparqlContext,
            "solutionModifier",
            ISolutionModifier,
            undefined,
        > & GeneratorRule<
            undefined,
            "solutionModifier",
            ISolutionModifier,
            undefined,
        >;
        string: GeneratorRule<any, "string"> & ParserRule<
            SparqlContext,
            "string",
            string,
            undefined,
        > & GeneratorRule<undefined, "string", string, undefined>;
        triplesBlock: GeneratorRule<
            undefined,
            "triplesBlock",
            BgpPattern,
            undefined,
        >;
        update: GeneratorRule<any, "update"> & ParserRule<
            SparqlContext,
            "update",
            Update,
            undefined,
        > & GeneratorRule<undefined, "update", Update, undefined>;
        update1: GeneratorRule<any, "update1"> & ParserRule<
            SparqlContext,
            "update1",
            UpdateOperation,
            undefined,
        > & GeneratorRule<undefined, "update1", UpdateOperation, undefined>;
        valuesClause: GeneratorRule<any, "valuesClause"> & ParserRule<
            SparqlContext,
            "valuesClause",
            undefined
            | ValuePatternRow[],
            undefined,
        > & GeneratorRule<
            undefined,
            "valuesClause",
            undefined
            | ValuePatternRow[],
            undefined,
        >;
        var: GeneratorRule<any, "var"> & ParserRule<
            SparqlContext,
            "var",
            Variable,
            undefined,
        > & GeneratorRule<undefined, "var", Variable, undefined>;
        varOrTerm: GeneratorRule<any, "varOrTerm"> & ParserRule<
            SparqlContext,
            "varOrTerm",
            Term,
            undefined,
        > & GeneratorRule<undefined, "varOrTerm", Term, undefined>;
    },
> = ...