Variable toAst12BuilderConst

toAst12Builder: IndirBuilder<
    Patch<AstContext, { astFactory: Factory }>,

        | "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<
            Patch<AstContext, { astFactory: Factory }>,
            "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<
            Patch<AstContext, { astFactory: Factory }>,
            "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[]],
        >;
    },
> = ...