Variable triplesBlockParserBuilderConst

triplesBlockParserBuilder: ParserBuilder<
    SparqlContext,
    | "string"
    | "object"
    | "var"
    | "path"
    | "blankNode"
    | "rdfLiteral"
    | "iri"
    | "numericLiteral"
    | "numericLiteralUnsigned"
    | "numericLiteralPositive"
    | "numericLiteralNegative"
    | "booleanLiteral"
    | "iriFull"
    | "prefixedName"
    | "VerbA"
    | "verb"
    | "varOrIri"
    | "varOrTerm"
    | "graphTerm"
    | "pathAlternative"
    | "pathSequence"
    | "pathEltOrInverse"
    | "pathElt"
    | "pathMod"
    | "pathPrimary"
    | "pathNegatedPropertySet"
    | "pathOneInPropertySet"
    | "triplesBlock"
    | "triplesSameSubjectPath"
    | "propertyListPathNotEmpty"
    | "propertyListNotEmpty"
    | "triplesNodePath"
    | "triplesNode"
    | "propertyListPath"
    | "verbPath"
    | "verbSimple"
    | "objectList"
    | "objectListPath"
    | "graphNodePath"
    | "graphNode"
    | "objectPath"
    | "collection"
    | "collectionPath"
    | "blankNodePropertyListPath"
    | "blankNodePropertyList",
    {
        blankNode: ParserRule<any, "blankNode"> & SparqlGrammarRule<
            "blankNode",
            TermBlank,
            [],
        > & SparqlGeneratorRule<"blankNode", TermBlank, []>;
        blankNodePropertyList: ParserRule<any, "blankNodePropertyList"> & SparqlGrammarRule<
            "blankNodePropertyList",
            TripleCollectionBlankNodeProperties,
            [],
        > & SparqlGeneratorRule<
            "blankNodePropertyList",
            TripleCollectionBlankNodeProperties,
            [],
        >;
        blankNodePropertyListPath: ParserRule<any, "blankNodePropertyListPath"> & SparqlGrammarRule<
            "blankNodePropertyListPath",
            TripleCollectionBlankNodeProperties,
            [],
        > & SparqlGeneratorRule<
            "blankNodePropertyListPath",
            TripleCollectionBlankNodeProperties,
            [],
        >;
        booleanLiteral: ParserRule<any, "booleanLiteral"> & SparqlGrammarRule<
            "booleanLiteral",
            TermLiteralTyped,
        >;
        collection: ParserRule<any, "collection"> & SparqlGrammarRule<
            "collection",
            TripleCollectionList,
            [],
        > & SparqlGeneratorRule<"collection", TripleCollectionList, []>;
        collectionPath: ParserRule<any, "collectionPath"> & SparqlGrammarRule<
            "collectionPath",
            TripleCollectionList,
            [],
        > & SparqlGeneratorRule<"collectionPath", TripleCollectionList, []>;
        graphNode: ParserRule<any, "graphNode"> & SparqlGrammarRule<
            "graphNode",
            TripleCollection
            | Term,
            [],
        > & SparqlGeneratorRule<"graphNode", TripleCollection | Term, []>;
        graphNodePath: ParserRule<any, "graphNodePath"> & SparqlGrammarRule<
            "graphNodePath",
            TripleCollection
            | Term,
            [],
        > & SparqlGeneratorRule<"graphNodePath", TripleCollection | Term, []>;
        graphTerm: ParserRule<any, "graphTerm"> & SparqlGrammarRule<
            "graphTerm",
            GraphTerm,
            [],
        > & SparqlGeneratorRule<"graphTerm", GraphTerm, []>;
        iri: ParserRule<any, "iri"> & SparqlGrammarRule<"iri", TermIri, []> & SparqlGeneratorRule<
            "iri",
            TermIri,
            [],
        >;
        iriFull: ParserRule<any, "iriFull"> & SparqlGrammarRule<
            "iriFull",
            TermIriFull,
            [],
        > & SparqlGeneratorRule<"iriFull", TermIriFull, []>;
        numericLiteral: ParserRule<any, "numericLiteral"> & SparqlGrammarRule<
            "numericLiteral",
            TermLiteralTyped,
        >;
        numericLiteralNegative: ParserRule<any, "numericLiteralNegative"> & SparqlGrammarRule<
            "numericLiteralNegative",
            TermLiteralTyped,
        >;
        numericLiteralPositive: ParserRule<any, "numericLiteralPositive"> & SparqlGrammarRule<
            "numericLiteralPositive",
            TermLiteralTyped,
        >;
        numericLiteralUnsigned: ParserRule<any, "numericLiteralUnsigned"> & SparqlGrammarRule<
            "numericLiteralUnsigned",
            TermLiteralTyped,
        >;
        object: ParserRule<any, "object"> & SparqlGrammarRule<
            "object",
            TripleNesting,
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectList: ParserRule<any, "objectList"> & SparqlGrammarRule<
            "objectList",
            TripleNesting[],
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectListPath: ParserRule<any, "objectListPath"> & SparqlGrammarRule<
            "objectListPath",
            TripleNesting[],
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        objectPath: ParserRule<any, "objectPath"> & SparqlGrammarRule<
            "objectPath",
            TripleNesting,
            [
                GraphNode,
                | TermIriFull
                | TermIriPrefixed
                | TermVariable
                | PropertyPathChain
                | PathModified
                | PathNegated,
            ],
        >;
        path: ParserRule<any, "path"> & SparqlGrammarRule<"path", Path>;
        pathAlternative: ParserRule<any, "pathAlternative"> & SparqlGrammarRule<
            "pathAlternative",
            | TermIriFull
            | TermIriPrefixed
            | PropertyPathChain
            | PathModified
            | PathNegated,
        >;
        pathElt: ParserRule<any, "pathElt"> & SparqlGrammarRule<"pathElt", Path>;
        pathEltOrInverse: ParserRule<any, "pathEltOrInverse"> & SparqlGrammarRule<
            "pathEltOrInverse",
            Path,
        >;
        pathMod: ParserRule<any, "pathMod"> & SparqlGrammarRule<
            "pathMod",
            IToken & { image: "?"
            | "*"
            | "+" },
        >;
        pathNegatedPropertySet: ParserRule<any, "pathNegatedPropertySet"> & SparqlGrammarRule<
            "pathNegatedPropertySet",
            PathNegated,
        >;
        pathOneInPropertySet: ParserRule<any, "pathOneInPropertySet"> & SparqlGrammarRule<
            "pathOneInPropertySet",
            TermIri
            | PathNegatedElt,
        >;
        pathPrimary: ParserRule<any, "pathPrimary"> & SparqlGrammarRule<
            "pathPrimary",
            Path,
        >;
        pathSequence: ParserRule<any, "pathSequence"> & SparqlGrammarRule<
            "pathSequence",
            | TermIriFull
            | TermIriPrefixed
            | PropertyPathChain
            | PathModified
            | PathNegated,
        >;
        prefixedName: ParserRule<any, "prefixedName"> & SparqlGrammarRule<
            "prefixedName",
            TermIriPrefixed,
            [],
        > & SparqlGeneratorRule<"prefixedName", TermIriPrefixed, []>;
        propertyListNotEmpty: ParserRule<any, "propertyListNotEmpty"> & SparqlGrammarRule<
            "propertyListNotEmpty",
            TripleNesting[],
            [GraphNode],
        >;
        propertyListPath: ParserRule<any, "propertyListPath"> & SparqlGrammarRule<
            "propertyListPath",
            TripleNesting[],
            [GraphNode],
        >;
        propertyListPathNotEmpty: ParserRule<any, "propertyListPathNotEmpty"> & SparqlGrammarRule<
            "propertyListPathNotEmpty",
            TripleNesting[],
            [GraphNode],
        >;
        rdfLiteral: ParserRule<any, "rdfLiteral"> & SparqlGrammarRule<
            "rdfLiteral",
            TermLiteral,
            [],
        > & SparqlGeneratorRule<"rdfLiteral", TermLiteral, []>;
        string: ParserRule<any, "string"> & SparqlGrammarRule<
            "string",
            TermLiteralStr,
        >;
        triplesBlock: ParserRule<any, "triplesBlock"> & SparqlGrammarRule<
            "triplesBlock",
            PatternBgp,
            [],
        > & SparqlGeneratorRule<"triplesBlock", PatternBgp, []>;
        triplesNode: ParserRule<any, "triplesNode"> & SparqlGrammarRule<
            "triplesNode",
            TripleCollection,
            [],
        > & SparqlGeneratorRule<"triplesNode", TripleCollection, []>;
        triplesNodePath: ParserRule<any, "triplesNodePath"> & SparqlGrammarRule<
            "triplesNodePath",
            TripleCollection,
            [],
        > & SparqlGeneratorRule<"triplesNodePath", TripleCollection, []>;
        triplesSameSubjectPath: ParserRule<any, "triplesSameSubjectPath"> & SparqlGrammarRule<
            "triplesSameSubjectPath",
            BasicGraphPattern,
        >;
        var: ParserRule<any, "var"> & SparqlGrammarRule<"var", TermVariable, []> & SparqlGeneratorRule<
            "var",
            TermVariable,
            [],
        >;
        varOrIri: ParserRule<any, "varOrIri"> & SparqlGrammarRule<
            "varOrIri",
            TermIri
            | TermVariable,
        >;
        varOrTerm: ParserRule<any, "varOrTerm"> & SparqlGrammarRule<
            "varOrTerm",
            Term,
            [],
        > & SparqlGeneratorRule<"varOrTerm", Term, []>;
        verb: ParserRule<any, "verb"> & SparqlGrammarRule<
            "verb",
            TermIri
            | TermVariable,
        >;
        VerbA: ParserRule<any, "VerbA"> & SparqlGrammarRule<"VerbA", TermIriFull>;
        verbPath: ParserRule<any, "verbPath"> & SparqlGrammarRule<
            "verbPath",
            Path,
        >;
        verbSimple: ParserRule<any, "verbSimple"> & SparqlGrammarRule<
            "verbSimple",
            TermVariable,
        >;
    },
> = ...