Variable toAst11BuilderConst

toAst11Builder: IndirBuilder<
    AstContext,
    | "translateTerm"
    | "translatePath"
    | "translateGraphRef"
    | "translateBgp"
    | "translateBoundAggregate"
    | "resetContext"
    | "registerProjection"
    | "translatePathComponent"
    | "translateAlt"
    | "translateInv"
    | "translateLink"
    | "translateNps"
    | "translateOneOrMorePath"
    | "translateSeq"
    | "translateZeroOrMorePath"
    | "translateZeroOrOnePath"
    | "translateConstruct"
    | "replaceAggregatorVariables"
    | "translateProject"
    | "registerGroupBy"
    | "registerOrderBy"
    | "registerVariables"
    | "putExtensionsInGroup"
    | "filterReplace"
    | "objectContainsVariable"
    | "translatePattern"
    | "translatePatternNew"
    | "translatePureExpression"
    | "translateExpressionOrOrdering"
    | "translatePatternIntoGroup"
    | "translateDistinct"
    | "translateFrom"
    | "translateFilter"
    | "translateReduced"
    | "translateSlice"
    | "translateSinglePattern"
    | "translateGraph"
    | "translateService"
    | "translateUnion"
    | "translateValues"
    | "translateOrderBy"
    | "translateGroup"
    | "translateExtend"
    | "translateJoin"
    | "translateLeftJoin"
    | "translateMinus"
    | "operationInputAsPatternList"
    | "wrapInPatternGroup"
    | "translateDatasetClauses"
    | "translateAggregateExpression"
    | "translateExistenceExpression"
    | "translateNamedExpression"
    | "translatePureOperatorExpression"
    | "translateExpressionOrWild"
    | "translateWildcardExpression"
    | "translateOperatorExpression"
    | "translateAnyExpression"
    | "removeQuads"
    | "removeQuadsRecursive"
    | "splitBgpToGraphs"
    | "translateUpdateOperation"
    | "translateDeleteInsert"
    | "translateLoad"
    | "translateClear"
    | "translateCreate"
    | "translateDrop"
    | "translateAdd"
    | "translateMove"
    | "translateCopy"
    | "toUpdate"
    | "translateCompositeUpdate"
    | "cleanUpUpdateOperationModify"
    | "convertUpdatePatterns"
    | "toSparqlJs",
    {
        cleanUpUpdateOperationModify: IndirDef<
            any,
            "cleanUpUpdateOperationModify",
            unknown,
            any[],
        > & AstIndir<
            "cleanUpUpdateOperationModify",
            LikeModify,
            [UpdateOperationModify, Algebra.DeleteInsert],
        >;
        convertUpdatePatterns: IndirDef<
            any,
            "convertUpdatePatterns",
            unknown,
            any[],
        > & AstIndir<"convertUpdatePatterns", Quads[], [Algebra.Pattern[]]>;
        filterReplace: IndirDef<any, "filterReplace", unknown, any[]> & AstIndir<
            "filterReplace",
            Pattern,
            [Pattern, Record<string, Expression>, Expression[]],
        >;
        objectContainsVariable: IndirDef<
            any,
            "objectContainsVariable",
            unknown,
            any[],
        > & AstIndir<"objectContainsVariable", boolean, [any, string[]]>;
        operationInputAsPatternList: IndirDef<
            any,
            "operationInputAsPatternList",
            unknown,
            any[],
        > & AstIndir<
            "operationInputAsPatternList",
            Pattern[],
            [Algebra.Operation],
        >;
        putExtensionsInGroup: IndirDef<
            any,
            "putExtensionsInGroup",
            unknown,
            any[],
        > & AstIndir<
            "putExtensionsInGroup",
            void,
            [QueryBase, Record<string, Expression>],
        >;
        registerGroupBy: IndirDef<any, "registerGroupBy", unknown, any[]> & AstIndir<
            "registerGroupBy",
            void,
            [QueryBase, Record<string, Expression>],
        >;
        registerOrderBy: IndirDef<any, "registerOrderBy", unknown, any[]> & AstIndir<
            "registerOrderBy",
            void,
            [QueryBase],
        >;
        registerProjection: IndirDef<any, "registerProjection", unknown, any[]> & AstIndir<
            "registerProjection",
            void,
            [Algebra.Operation],
        >;
        registerVariables: IndirDef<any, "registerVariables", unknown, any[]> & AstIndir<
            "registerVariables",
            void,
            [QuerySelect, undefined | Variable[], Record<string, Expression>],
        >;
        removeQuads: IndirDef<any, "removeQuads", unknown, any[]> & AstIndir<
            "removeQuads",
            Algebra.Operation,
            [Algebra.Operation],
        >;
        removeQuadsRecursive: IndirDef<
            any,
            "removeQuadsRecursive",
            unknown,
            any[],
        > & AstIndir<
            "removeQuadsRecursive",
            unknown,
            [
                Algebra.Operation
                | Algebra.Operation[],
                (DefaultGraph | NamedNode<string>)[],
            ],
        >;
        replaceAggregatorVariables: IndirDef<
            any,
            "replaceAggregatorVariables",
            unknown,
            any[],
        > & AstIndir<
            "replaceAggregatorVariables",
            unknown,
            [unknown, Record<string, Expression>],
        >;
        resetContext: IndirDef<any, "resetContext", unknown, any[]> & AstIndir<
            "resetContext",
            void,
            [],
        >;
        splitBgpToGraphs: IndirDef<any, "splitBgpToGraphs", unknown, any[]> & AstIndir<
            "splitBgpToGraphs",
            Algebra.Bgp
            | Algebra.Graph
            | Algebra.Join,
            [Algebra.Bgp, (DefaultGraph | NamedNode<string>)[]],
        >;
        toSparqlJs: IndirDef<any, "toSparqlJs", unknown, any[]> & AstIndir<
            "toSparqlJs",
            SparqlQuery,
            [Algebra.Operation],
        >;
        toUpdate: IndirDef<any, "toUpdate", unknown, any[]> & AstIndir<
            "toUpdate",
            Update,
            [UpdateOperation[]],
        >;
        translateAdd: IndirDef<any, "translateAdd", unknown, any[]> & AstIndir<
            "translateAdd",
            UpdateOperationAdd,
            [Algebra.Add],
        >;
        translateAggregateExpression: IndirDef<
            any,
            "translateAggregateExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateAggregateExpression",
            ExpressionAggregate,
            [Algebra.AggregateExpression],
        >;
        translateAlt: IndirDef<any, "translateAlt", unknown, any[]> & AstIndir<
            "translateAlt",
            Path,
            [Algebra.Alt],
        >;
        translateAnyExpression: IndirDef<
            any,
            "translateAnyExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateAnyExpression",
            Expression
            | Wildcard
            | Ordering,
            [Algebra.Expression],
        >;
        translateBgp: IndirDef<any, "translateBgp", unknown, any[]> & AstIndir<
            "translateBgp",
            PatternBgp,
            [Algebra.Bgp],
        >;
        translateBoundAggregate: IndirDef<
            any,
            "translateBoundAggregate",
            unknown,
            any[],
        > & AstIndir<
            "translateBoundAggregate",
            Algebra.BoundAggregate,
            [Algebra.BoundAggregate],
        >;
        translateClear: IndirDef<any, "translateClear", unknown, any[]> & AstIndir<
            "translateClear",
            UpdateOperationClear,
            [Algebra.Clear],
        >;
        translateCompositeUpdate: IndirDef<
            any,
            "translateCompositeUpdate",
            unknown,
            any[],
        > & AstIndir<
            "translateCompositeUpdate",
            Update,
            [Algebra.CompositeUpdate],
        >;
        translateConstruct: IndirDef<any, "translateConstruct", unknown, any[]> & AstIndir<
            "translateConstruct",
            PatternGroup,
            [Algebra.Construct],
        >;
        translateCopy: IndirDef<any, "translateCopy", unknown, any[]> & AstIndir<
            "translateCopy",
            UpdateOperationCopy,
            [Algebra.Copy],
        >;
        translateCreate: IndirDef<any, "translateCreate", unknown, any[]> & AstIndir<
            "translateCreate",
            UpdateOperationCreate,
            [Algebra.Create],
        >;
        translateDatasetClauses: IndirDef<
            any,
            "translateDatasetClauses",
            unknown,
            any[],
        > & AstIndir<
            "translateDatasetClauses",
            DatasetClauses,
            [NamedNode<string>[], NamedNode<string>[]],
        >;
        translateDeleteInsert: IndirDef<
            any,
            "translateDeleteInsert",
            unknown,
            any[],
        > & AstIndir<"translateDeleteInsert", LikeModify, [Algebra.DeleteInsert]>;
        translateDistinct: IndirDef<any, "translateDistinct", unknown, any[]> & AstIndir<
            "translateDistinct",
            PatternGroup,
            [Algebra.Distinct],
        >;
        translateDrop: IndirDef<any, "translateDrop", unknown, any[]> & AstIndir<
            "translateDrop",
            UpdateOperationDrop,
            [Algebra.Drop],
        >;
        translateExistenceExpression: IndirDef<
            any,
            "translateExistenceExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateExistenceExpression",
            ExpressionPatternOperation,
            [Algebra.ExistenceExpression],
        >;
        translateExpressionOrOrdering: IndirDef<
            any,
            "translateExpressionOrOrdering",
            unknown,
            any[],
        > & AstIndir<
            "translateExpressionOrOrdering",
            Expression
            | Ordering,
            [Algebra.Expression],
        >;
        translateExpressionOrWild: IndirDef<
            any,
            "translateExpressionOrWild",
            unknown,
            any[],
        > & AstIndir<
            "translateExpressionOrWild",
            Expression
            | Wildcard,
            [Algebra.Expression],
        >;
        translateExtend: IndirDef<any, "translateExtend", unknown, any[]> & AstIndir<
            "translateExtend",
            Pattern
            | Pattern[],
            [Algebra.Extend],
        >;
        translateFilter: IndirDef<any, "translateFilter", unknown, any[]> & AstIndir<
            "translateFilter",
            PatternGroup,
            [Algebra.Filter],
        >;
        translateFrom: IndirDef<any, "translateFrom", unknown, any[]> & AstIndir<
            "translateFrom",
            PatternGroup,
            [Algebra.From],
        >;
        translateGraph: IndirDef<any, "translateGraph", unknown, any[]> & AstIndir<
            "translateGraph",
            PatternGraph,
            [Algebra.Graph],
        >;
        translateGraphRef: IndirDef<any, "translateGraphRef", unknown, any[]> & AstIndir<
            "translateGraphRef",
            GraphRef,
            [NamedNode<string> | "NAMED" | "DEFAULT" | "ALL"],
        >;
        translateGroup: IndirDef<any, "translateGroup", unknown, any[]> & AstIndir<
            "translateGroup",
            Pattern
            | Pattern[],
            [Algebra.Group],
        >;
        translateInv: IndirDef<any, "translateInv", unknown, any[]> & AstIndir<
            "translateInv",
            Path,
            [Algebra.Inv],
        >;
        translateJoin: IndirDef<any, "translateJoin", unknown, any[]> & AstIndir<
            "translateJoin",
            Pattern[],
            [Algebra.Join],
        >;
        translateLeftJoin: IndirDef<any, "translateLeftJoin", unknown, any[]> & AstIndir<
            "translateLeftJoin",
            Pattern[],
            [Algebra.LeftJoin],
        >;
        translateLink: IndirDef<any, "translateLink", unknown, any[]> & AstIndir<
            "translateLink",
            TermIri,
            [Algebra.Link],
        >;
        translateLoad: IndirDef<any, "translateLoad", unknown, any[]> & AstIndir<
            "translateLoad",
            UpdateOperationLoad,
            [Algebra.Load],
        >;
        translateMinus: IndirDef<any, "translateMinus", unknown, any[]> & AstIndir<
            "translateMinus",
            Pattern[],
            [Algebra.Minus],
        >;
        translateMove: IndirDef<any, "translateMove", unknown, any[]> & AstIndir<
            "translateMove",
            UpdateOperationMove,
            [Algebra.Move],
        >;
        translateNamedExpression: IndirDef<
            any,
            "translateNamedExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateNamedExpression",
            ExpressionFunctionCall,
            [Algebra.NamedExpression],
        >;
        translateNps: IndirDef<any, "translateNps", unknown, any[]> & AstIndir<
            "translateNps",
            Path,
            [Algebra.Nps],
        >;
        translateOneOrMorePath: IndirDef<
            any,
            "translateOneOrMorePath",
            unknown,
            any[],
        > & AstIndir<
            "translateOneOrMorePath",
            PathModified,
            [Algebra.OneOrMorePath],
        >;
        translateOperatorExpression: IndirDef<
            any,
            "translateOperatorExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateOperatorExpression",
            ExpressionOperation
            | Ordering,
            [Algebra.OperatorExpression],
        >;
        translateOrderBy: IndirDef<any, "translateOrderBy", unknown, any[]> & AstIndir<
            "translateOrderBy",
            Pattern
            | Pattern[],
            [Algebra.OrderBy],
        >;
        translatePath: IndirDef<any, "translatePath", unknown, any[]> & AstIndir<
            "translatePath",
            PatternBgp,
            [Algebra.Path],
        >;
        translatePathComponent: IndirDef<
            any,
            "translatePathComponent",
            unknown,
            any[],
        > & AstIndir<"translatePathComponent", Path, [Algebra.Operation]>;
        translatePattern: IndirDef<any, "translatePattern", unknown, any[]> & AstIndir<
            "translatePattern",
            TripleNesting,
            [Algebra.Pattern],
        >;
        translatePatternIntoGroup: IndirDef<
            any,
            "translatePatternIntoGroup",
            unknown,
            any[],
        > & AstIndir<
            "translatePatternIntoGroup",
            PatternGroup,
            [Algebra.Operation],
        >;
        translatePatternNew: IndirDef<any, "translatePatternNew", unknown, any[]> & AstIndir<
            "translatePatternNew",
            Pattern
            | Pattern[],
            [Algebra.Operation],
        >;
        translateProject: IndirDef<any, "translateProject", unknown, any[]> & AstIndir<
            "translateProject",
            PatternGroup,
            [Algebra.Ask | Algebra.Describe | Algebra.Project, string],
        >;
        translatePureExpression: IndirDef<
            any,
            "translatePureExpression",
            unknown,
            any[],
        > & AstIndir<"translatePureExpression", Expression, [Algebra.Expression]>;
        translatePureOperatorExpression: IndirDef<
            any,
            "translatePureOperatorExpression",
            unknown,
            any[],
        > & AstIndir<
            "translatePureOperatorExpression",
            ExpressionOperation,
            [Algebra.OperatorExpression],
        >;
        translateReduced: IndirDef<any, "translateReduced", unknown, any[]> & AstIndir<
            "translateReduced",
            PatternGroup,
            [Algebra.Reduced],
        >;
        translateSeq: IndirDef<any, "translateSeq", unknown, any[]> & AstIndir<
            "translateSeq",
            PropertyPathChain,
            [Algebra.Seq],
        >;
        translateService: IndirDef<any, "translateService", unknown, any[]> & AstIndir<
            "translateService",
            PatternService,
            [Algebra.Service],
        >;
        translateSinglePattern: IndirDef<
            any,
            "translateSinglePattern",
            unknown,
            any[],
        > & AstIndir<"translateSinglePattern", Pattern, [Algebra.Operation]>;
        translateSlice: IndirDef<any, "translateSlice", unknown, any[]> & AstIndir<
            "translateSlice",
            PatternGroup,
            [Algebra.Slice],
        >;
        translateTerm: IndirDef<any, "translateTerm", unknown, any[]> & AstIndir<
            "translateTerm",
            Term,
            [Term],
        >;
        translateUnion: IndirDef<any, "translateUnion", unknown, any[]> & AstIndir<
            "translateUnion",
            PatternUnion,
            [Algebra.Union],
        >;
        translateUpdateOperation: IndirDef<
            any,
            "translateUpdateOperation",
            unknown,
            any[],
        > & AstIndir<
            "translateUpdateOperation",
            UpdateOperation,
            [Algebra.Operation],
        >;
        translateValues: IndirDef<any, "translateValues", unknown, any[]> & AstIndir<
            "translateValues",
            PatternValues,
            [Algebra.Values],
        >;
        translateWildcardExpression: IndirDef<
            any,
            "translateWildcardExpression",
            unknown,
            any[],
        > & AstIndir<
            "translateWildcardExpression",
            Wildcard,
            [Algebra.WildcardExpression],
        >;
        translateZeroOrMorePath: IndirDef<
            any,
            "translateZeroOrMorePath",
            unknown,
            any[],
        > & AstIndir<
            "translateZeroOrMorePath",
            PathModified,
            [Algebra.ZeroOrMorePath],
        >;
        translateZeroOrOnePath: IndirDef<
            any,
            "translateZeroOrOnePath",
            unknown,
            any[],
        > & AstIndir<
            "translateZeroOrOnePath",
            PathModified,
            [Algebra.ZeroOrOnePath],
        >;
        wrapInPatternGroup: IndirDef<any, "wrapInPatternGroup", unknown, any[]> & AstIndir<
            "wrapInPatternGroup",
            PatternGroup,
            [Pattern | Pattern[]],
        >;
    },
> = ...