Variable updateNoModifyParserBuilderConst

updateNoModifyParserBuilder: ParserBuilder<
    SparqlContext,
    | "string"
    | "object"
    | "add"
    | "clear"
    | "copy"
    | "move"
    | "var"
    | "drop"
    | "load"
    | "update"
    | "quads"
    | "create"
    | "rdfLiteral"
    | "iri"
    | "numericLiteral"
    | "numericLiteralUnsigned"
    | "numericLiteralPositive"
    | "numericLiteralNegative"
    | "booleanLiteral"
    | "prefixedName"
    | "blankNode"
    | "prologue"
    | "baseDecl"
    | "prefixDecl"
    | "verb"
    | "varOrIri"
    | "VerbA"
    | "varOrTerm"
    | "graphTerm"
    | "propertyListNotEmpty"
    | "propertyList"
    | "triplesNode"
    | "triplesSameSubject"
    | "triplesTemplate"
    | "objectList"
    | "graphNode"
    | "collection"
    | "blankNodePropertyList"
    | "updateUnit"
    | "update1"
    | "insertData"
    | "deleteData"
    | "deleteWhere"
    | "graphRef"
    | "graphRefAll"
    | "graphOrDefault"
    | "quadData"
    | "quadPattern"
    | "quadsNotTriples",
    {
        add: ParserRule<any, "add"> & ParserRule<
            SparqlContext,
            "add",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "add", CopyMoveAddOperation, undefined>;
        baseDecl: ParserRule<any, "baseDecl"> & SparqlGrammarRule<
            "baseDecl",
            string,
        >;
        blankNode: ParserRule<any, "blankNode"> & ParserRule<
            SparqlContext,
            "blankNode",
            BlankNode,
            undefined,
        > & GeneratorRule<undefined, "blankNode", BlankNode, undefined>;
        blankNodePropertyList: ParserRule<any, "blankNodePropertyList"> & SparqlGrammarRule<
            "blankNodePropertyList",
            ITriplesNode,
        >;
        booleanLiteral: ParserRule<any, "booleanLiteral"> & SparqlGrammarRule<
            "booleanLiteral",
            Literal,
        >;
        clear: ParserRule<any, "clear"> & ParserRule<
            SparqlContext,
            "clear",
            ClearDropOperation,
            undefined,
        > & GeneratorRule<undefined, "clear", ClearDropOperation, undefined>;
        collection: ParserRule<any, "collection"> & SparqlGrammarRule<
            "collection",
            ITriplesNode,
        >;
        copy: ParserRule<any, "copy"> & ParserRule<
            SparqlContext,
            "copy",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "copy", CopyMoveAddOperation, undefined>;
        create: ParserRule<any, "create"> & ParserRule<
            SparqlContext,
            "create",
            CreateOperation,
            undefined,
        > & GeneratorRule<undefined, "create", CreateOperation, undefined>;
        deleteData: ParserRule<any, "deleteData"> & ParserRule<
            SparqlContext,
            "deleteData",
            DeleteOperation,
            undefined,
        > & GeneratorRule<undefined, "deleteData", DeleteOperation, undefined>;
        deleteWhere: ParserRule<any, "deleteWhere"> & ParserRule<
            SparqlContext,
            "deleteWhere",
            DeleteWhereOperation,
            undefined,
        > & GeneratorRule<
            undefined,
            "deleteWhere",
            DeleteWhereOperation,
            undefined,
        >;
        drop: ParserRule<any, "drop"> & ParserRule<
            SparqlContext,
            "drop",
            ClearDropOperation,
            undefined,
        > & GeneratorRule<undefined, "drop", ClearDropOperation, undefined>;
        graphNode: ParserRule<any, "graphNode"> & SparqlGrammarRule<
            "graphNode",
            IGraphNode,
        >;
        graphOrDefault: ParserRule<any, "graphOrDefault"> & ParserRule<
            SparqlContext,
            "graphOrDefault",
            GraphOrDefault,
            undefined,
        > & GeneratorRule<undefined, "graphOrDefault", GraphOrDefault, undefined>;
        graphRef: ParserRule<any, "graphRef"> & ParserRule<
            SparqlContext,
            "graphRef",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "graphRef", IriTerm, undefined>;
        graphRefAll: ParserRule<any, "graphRefAll"> & ParserRule<
            SparqlContext,
            "graphRefAll",
            GraphReference,
            undefined,
        > & GeneratorRule<undefined, "graphRefAll", GraphReference, undefined>;
        graphTerm: ParserRule<any, "graphTerm"> & ParserRule<
            SparqlContext,
            "graphTerm",
            GraphTerm,
            undefined,
        > & GeneratorRule<undefined, "graphTerm", GraphTerm, undefined>;
        insertData: ParserRule<any, "insertData"> & ParserRule<
            SparqlContext,
            "insertData",
            InsertOperation,
            undefined,
        > & GeneratorRule<undefined, "insertData", InsertOperation, undefined>;
        iri: ParserRule<any, "iri"> & ParserRule<
            SparqlContext,
            "iri",
            IriTerm,
            undefined,
        > & GeneratorRule<undefined, "iri", IriTerm, undefined>;
        load: ParserRule<any, "load"> & ParserRule<
            SparqlContext,
            "load",
            LoadOperation,
            undefined,
        > & GeneratorRule<undefined, "load", LoadOperation, undefined>;
        move: ParserRule<any, "move"> & ParserRule<
            SparqlContext,
            "move",
            CopyMoveAddOperation,
            undefined,
        > & GeneratorRule<undefined, "move", CopyMoveAddOperation, 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">,
        >;
        prefixDecl: ParserRule<any, "prefixDecl"> & SparqlGrammarRule<
            "prefixDecl",
            [string, string],
        >;
        prefixedName: ParserRule<any, "prefixedName"> & SparqlGrammarRule<
            "prefixedName",
            IriTerm,
        >;
        prologue: ParserRule<any, "prologue"> & ParserRule<
            SparqlContext,
            "prologue",
            Pick<BaseQuery, "base" | "prefixes">,
            undefined,
        > & GeneratorRule<
            undefined,
            "prologue",
            Pick<BaseQuery, "base" | "prefixes">,
            undefined,
        >;
        propertyList: ParserRule<any, "propertyList"> & SparqlGrammarRule<
            "propertyList",
            Triple[],
            Pick<Triple, "subject">,
        >;
        propertyListNotEmpty: ParserRule<any, "propertyListNotEmpty"> & SparqlGrammarRule<
            "propertyListNotEmpty",
            Triple[],
            Pick<Triple, "subject">,
        >;
        quadData: ParserRule<any, "quadData"> & ParserRule<
            SparqlContext,
            "quadData",
            Quads[],
            undefined,
        > & GeneratorRule<undefined, "quadData", Quads[], undefined>;
        quadPattern: ParserRule<SparqlContext, "quadPattern", Quads[], undefined>;
        quads: ParserRule<any, "quads"> & ParserRule<
            SparqlContext,
            "quads",
            Quads[],
            undefined,
        > & GeneratorRule<undefined, "quads", Quads[], undefined>;
        quadsNotTriples: ParserRule<
            SparqlContext,
            "quadsNotTriples",
            GraphQuads,
            undefined,
        >;
        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>;
        triplesNode: ParserRule<any, "triplesNode"> & SparqlGrammarRule<
            "triplesNode",
            ITriplesNode,
        >;
        triplesSameSubject: ParserRule<any, "triplesSameSubject"> & SparqlGrammarRule<
            "triplesSameSubject",
            Triple[],
        >;
        triplesTemplate: ParserRule<any, "triplesTemplate"> & SparqlGrammarRule<
            "triplesTemplate",
            Triple[],
        >;
        update: ParserRule<any, "update"> & ParserRule<
            SparqlContext,
            "update",
            Update,
            undefined,
        > & GeneratorRule<undefined, "update", Update, undefined>;
        update1: ParserRule<SparqlContext, "update1", UpdateOperation, undefined>;
        updateUnit: ParserRule<any, "updateUnit"> & SparqlGrammarRule<
            "updateUnit",
            Update,
        >;
        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>;
    },
> = ...