Variable triplesBlockParserBuilderConst

triplesBlockParserBuilder: ParserBuilder<
    SparqlContext,
    | "string"
    | "object"
    | "var"
    | "path"
    | "rdfLiteral"
    | "iri"
    | "numericLiteral"
    | "numericLiteralUnsigned"
    | "numericLiteralPositive"
    | "numericLiteralNegative"
    | "booleanLiteral"
    | "prefixedName"
    | "blankNode"
    | "verb"
    | "varOrIri"
    | "VerbA"
    | "varOrTerm"
    | "graphTerm"
    | "pathAlternative"
    | "pathSequence"
    | "pathEltOrInverse"
    | "pathElt"
    | "pathMod"
    | "pathPrimary"
    | "pathNegatedPropertySet"
    | "pathOneInPropertySet"
    | "triplesBlock"
    | "triplesSameSubjectPath"
    | "propertyListPathNotEmpty"
    | "propertyListNotEmpty"
    | "propertyListPath"
    | "triplesNodePath"
    | "triplesNode"
    | "verbPath"
    | "verbSimple"
    | "objectList"
    | "objectListPath"
    | "graphNodePath"
    | "graphNode"
    | "objectPath"
    | "collection"
    | "blankNodePropertyList"
    | "collectionPath"
    | "blankNodePropertyListPath",
    {
        blankNode: ParserRule<any, "blankNode"> & ParserRule<
            SparqlContext,
            "blankNode",
            BlankNode,
            undefined,
        > & GeneratorRule<undefined, "blankNode", BlankNode, undefined>;
        blankNodePropertyList: ParserRule<any, "blankNodePropertyList"> & SparqlGrammarRule<
            "blankNodePropertyList",
            ITriplesNode,
        >;
        blankNodePropertyListPath: ParserRule<any, "blankNodePropertyListPath"> & SparqlGrammarRule<
            "blankNodePropertyListPath",
            ITriplesNode,
        >;
        booleanLiteral: ParserRule<any, "booleanLiteral"> & SparqlGrammarRule<
            "booleanLiteral",
            Literal,
        >;
        collection: ParserRule<any, "collection"> & SparqlGrammarRule<
            "collection",
            ITriplesNode,
        >;
        collectionPath: ParserRule<any, "collectionPath"> & SparqlGrammarRule<
            "collectionPath",
            ITriplesNode,
        >;
        graphNode: ParserRule<any, "graphNode"> & SparqlGrammarRule<
            "graphNode",
            IGraphNode,
        >;
        graphNodePath: ParserRule<any, "graphNodePath"> & SparqlGrammarRule<
            "graphNodePath",
            IGraphNode,
        >;
        graphTerm: ParserRule<any, "graphTerm"> & ParserRule<
            SparqlContext,
            "graphTerm",
            GraphTerm,
            undefined,
        > & GeneratorRule<undefined, "graphTerm", GraphTerm, undefined>;
        iri: ParserRule<any, "iri"> & ParserRule<
            SparqlContext,
            "iri",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "iri", IriTerm, undefined>;
        numericLiteral: ParserRule<any, "numericLiteral"> & SparqlGrammarRule<
            "numericLiteral",
            Literal,
        >;
        numericLiteralNegative: ParserRule<any, "numericLiteralNegative"> & SparqlGrammarRule<
            "numericLiteralNegative",
            Literal,
        >;
        numericLiteralPositive: ParserRule<any, "numericLiteralPositive"> & SparqlGrammarRule<
            "numericLiteralPositive",
            Literal,
        >;
        numericLiteralUnsigned: ParserRule<any, "numericLiteralUnsigned"> & SparqlGrammarRule<
            "numericLiteralUnsigned",
            Literal,
        >;
        object: ParserRule<any, "object"> & SparqlGrammarRule<
            "object",
            Triple[],
            Pick<Triple, "subject" | "predicate">,
        >;
        objectList: ParserRule<any, "objectList"> & SparqlGrammarRule<
            "objectList",
            Triple[],
            Pick<Triple, "subject" | "predicate">,
        >;
        objectListPath: ParserRule<any, "objectListPath"> & SparqlGrammarRule<
            "objectListPath",
            Triple[],
            Pick<Triple, "subject" | "predicate">,
        >;
        objectPath: ParserRule<any, "objectPath"> & SparqlGrammarRule<
            "objectPath",
            Triple[],
            Pick<Triple, "subject" | "predicate">,
        >;
        path: ParserRule<any, "path"> & ParserRule<
            SparqlContext,
            "path",
            PropertyPath
            | IriTerm,
            undefined,
        > & GeneratorRule<undefined, "path", PropertyPath | IriTerm, undefined>;
        pathAlternative: ParserRule<any, "pathAlternative"> & SparqlGrammarRule<
            "pathAlternative",
            PropertyPath
            | IriTerm,
        >;
        pathElt: ParserRule<any, "pathElt"> & SparqlGrammarRule<
            "pathElt",
            PropertyPath
            | IriTerm,
        >;
        pathEltOrInverse: ParserRule<any, "pathEltOrInverse"> & SparqlGrammarRule<
            "pathEltOrInverse",
            PropertyPath
            | IriTerm,
        >;
        pathMod: ParserRule<any, "pathMod"> & SparqlGrammarRule<
            "pathMod",
            "?"
            | "*"
            | "+",
        >;
        pathNegatedPropertySet: ParserRule<any, "pathNegatedPropertySet"> & SparqlGrammarRule<
            "pathNegatedPropertySet",
            [IriTermOrElt]
            | [{ items: IriTermOrElt[]; pathType: "|"; type: "path" }],
        >;
        pathOneInPropertySet: ParserRule<any, "pathOneInPropertySet"> & SparqlGrammarRule<
            "pathOneInPropertySet",
            IriTermOrElt,
        >;
        pathPrimary: ParserRule<any, "pathPrimary"> & SparqlGrammarRule<
            "pathPrimary",
            PropertyPath
            | IriTerm,
        >;
        pathSequence: ParserRule<any, "pathSequence"> & SparqlGrammarRule<
            "pathSequence",
            PropertyPath
            | IriTerm,
        >;
        prefixedName: ParserRule<any, "prefixedName"> & SparqlGrammarRule<
            "prefixedName",
            IriTerm,
        >;
        propertyListNotEmpty: ParserRule<any, "propertyListNotEmpty"> & SparqlGrammarRule<
            "propertyListNotEmpty",
            Triple[],
            Pick<Triple, "subject">,
        >;
        propertyListPath: ParserRule<any, "propertyListPath"> & SparqlGrammarRule<
            "propertyListPath",
            Triple[],
            Pick<Triple, "subject">,
        >;
        propertyListPathNotEmpty: ParserRule<any, "propertyListPathNotEmpty"> & SparqlGrammarRule<
            "propertyListPathNotEmpty",
            Triple[],
            Pick<Triple, "subject">,
        >;
        rdfLiteral: ParserRule<any, "rdfLiteral"> & ParserRule<
            SparqlContext,
            "rdfLiteral",
            Literal,
            undefined,
        > & GeneratorRule<undefined, "rdfLiteral", Literal, undefined>;
        string: ParserRule<any, "string"> & ParserRule<
            SparqlContext,
            "string",
            string,
            undefined,
        > & GeneratorRule<undefined, "string", string, undefined>;
        triplesBlock: ParserRule<any, "triplesBlock"> & ParserRule<
            SparqlContext,
            "triplesBlock",
            BgpPattern,
            undefined,
        > & GeneratorRule<undefined, "triplesBlock", BgpPattern, undefined>;
        triplesNode: ParserRule<any, "triplesNode"> & SparqlGrammarRule<
            "triplesNode",
            ITriplesNode,
        >;
        triplesNodePath: ParserRule<any, "triplesNodePath"> & SparqlGrammarRule<
            "triplesNodePath",
            ITriplesNode,
        >;
        triplesSameSubjectPath: ParserRule<any, "triplesSameSubjectPath"> & SparqlGrammarRule<
            "triplesSameSubjectPath",
            Triple[],
        >;
        var: ParserRule<any, "var"> & ParserRule<
            SparqlContext,
            "var",
            Variable,
            undefined,
        > & GeneratorRule<undefined, "var", Variable, undefined>;
        varOrIri: ParserRule<any, "varOrIri"> & SparqlGrammarRule<
            "varOrIri",
            Variable
            | IriTerm,
        >;
        varOrTerm: ParserRule<any, "varOrTerm"> & ParserRule<
            SparqlContext,
            "varOrTerm",
            Term,
            undefined,
        > & GeneratorRule<undefined, "varOrTerm", Term, undefined>;
        verb: ParserRule<any, "verb"> & SparqlGrammarRule<
            "verb",
            Variable
            | IriTerm,
        >;
        VerbA: ParserRule<any, "VerbA"> & SparqlGrammarRule<"VerbA", VerbA>;
        verbPath: ParserRule<any, "verbPath"> & SparqlGrammarRule<
            "verbPath",
            PropertyPath
            | IriTerm,
        >;
        verbSimple: ParserRule<any, "verbSimple"> & SparqlGrammarRule<
            "verbSimple",
            Variable,
        >;
    },
> = ...