Variable mapOperationSubAsyncConst

Type Declaration

• • <Safe extends Safeness = "safe", OutType = unknown>(
        startObject: object,
        nodeCallBacks: {
            add?: {
                preVisitor?: (orig: Algebra.Add) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Add>,
                    orig: Algebra.Add,
                ) => unknown;
            };
            alt?: {
                preVisitor?: (orig: Algebra.Alt) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Alt>,
                    orig: Algebra.Alt,
                ) => unknown;
            };
            ask?: {
                preVisitor?: (orig: Algebra.Ask) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Ask>,
                    orig: Algebra.Ask,
                ) => unknown;
            };
            bgp?: {
                preVisitor?: (orig: Algebra.Bgp) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Bgp>,
                    orig: Algebra.Bgp,
                ) => unknown;
            };
            clear?: {
                preVisitor?: (orig: Algebra.Clear) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Clear>,
                    orig: Algebra.Clear,
                ) => unknown;
            };
            compositeupdate?: {
                preVisitor?: (
                    orig: Algebra.CompositeUpdate,
                ) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.CompositeUpdate>,
                    orig: Algebra.CompositeUpdate,
                ) => unknown;
            };
            construct?: {
                preVisitor?: (orig: Algebra.Construct) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Construct>,
                    orig: Algebra.Construct,
                ) => unknown;
            };
            copy?: {
                preVisitor?: (orig: Algebra.Copy) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Copy>,
                    orig: Algebra.Copy,
                ) => unknown;
            };
            create?: {
                preVisitor?: (orig: Algebra.Create) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Create>,
                    orig: Algebra.Create,
                ) => unknown;
            };
            deleteinsert?: {
                preVisitor?: (
                    orig: Algebra.DeleteInsert,
                ) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.DeleteInsert>,
                    orig: Algebra.DeleteInsert,
                ) => unknown;
            };
            describe?: {
                preVisitor?: (orig: Algebra.Describe) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Describe>,
                    orig: Algebra.Describe,
                ) => unknown;
            };
            distinct?: {
                preVisitor?: (orig: Algebra.Distinct) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Distinct>,
                    orig: Algebra.Distinct,
                ) => unknown;
            };
            drop?: {
                preVisitor?: (orig: Algebra.Drop) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Drop>,
                    orig: Algebra.Drop,
                ) => unknown;
            };
            expression?: {
                preVisitor?: (orig: Algebra.Expression) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Expression>,
                    orig: Algebra.Expression,
                ) => unknown;
            };
            extend?: {
                preVisitor?: (orig: Algebra.Extend) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Extend>,
                    orig: Algebra.Extend,
                ) => unknown;
            };
            filter?: {
                preVisitor?: (orig: Algebra.Filter) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Filter>,
                    orig: Algebra.Filter,
                ) => unknown;
            };
            from?: {
                preVisitor?: (orig: Algebra.From) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.From>,
                    orig: Algebra.From,
                ) => unknown;
            };
            graph?: {
                preVisitor?: (orig: Algebra.Graph) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Graph>,
                    orig: Algebra.Graph,
                ) => unknown;
            };
            group?: {
                preVisitor?: (orig: Algebra.Group) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Group>,
                    orig: Algebra.Group,
                ) => unknown;
            };
            inv?: {
                preVisitor?: (orig: Algebra.Inv) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Inv>,
                    orig: Algebra.Inv,
                ) => unknown;
            };
            join?: {
                preVisitor?: (orig: Algebra.Join) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Join>,
                    orig: Algebra.Join,
                ) => unknown;
            };
            leftjoin?: {
                preVisitor?: (orig: Algebra.LeftJoin) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.LeftJoin>,
                    orig: Algebra.LeftJoin,
                ) => unknown;
            };
            link?: {
                preVisitor?: (orig: Algebra.Link) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Link>,
                    orig: Algebra.Link,
                ) => unknown;
            };
            load?: {
                preVisitor?: (orig: Algebra.Load) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Load>,
                    orig: Algebra.Load,
                ) => unknown;
            };
            minus?: {
                preVisitor?: (orig: Algebra.Minus) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Minus>,
                    orig: Algebra.Minus,
                ) => unknown;
            };
            move?: {
                preVisitor?: (orig: Algebra.Move) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Move>,
                    orig: Algebra.Move,
                ) => unknown;
            };
            nop?: {
                preVisitor?: (orig: Algebra.Nop) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Nop>,
                    orig: Algebra.Nop,
                ) => unknown;
            };
            nps?: {
                preVisitor?: (orig: Algebra.Nps) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Nps>,
                    orig: Algebra.Nps,
                ) => unknown;
            };
            OneOrMorePath?: {
                preVisitor?: (
                    orig: Algebra.OneOrMorePath,
                ) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.OneOrMorePath>,
                    orig: Algebra.OneOrMorePath,
                ) => unknown;
            };
            orderby?: {
                preVisitor?: (orig: Algebra.OrderBy) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.OrderBy>,
                    orig: Algebra.OrderBy,
                ) => unknown;
            };
            path?: {
                preVisitor?: (orig: Algebra.Path) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Path>,
                    orig: Algebra.Path,
                ) => unknown;
            };
            pattern?: {
                preVisitor?: (orig: Algebra.Pattern) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Pattern>,
                    orig: Algebra.Pattern,
                ) => unknown;
            };
            project?: {
                preVisitor?: (orig: Algebra.Project) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Project>,
                    orig: Algebra.Project,
                ) => unknown;
            };
            reduced?: {
                preVisitor?: (orig: Algebra.Reduced) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Reduced>,
                    orig: Algebra.Reduced,
                ) => unknown;
            };
            seq?: {
                preVisitor?: (orig: Algebra.Seq) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Seq>,
                    orig: Algebra.Seq,
                ) => unknown;
            };
            service?: {
                preVisitor?: (orig: Algebra.Service) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Service>,
                    orig: Algebra.Service,
                ) => unknown;
            };
            slice?: {
                preVisitor?: (orig: Algebra.Slice) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Slice>,
                    orig: Algebra.Slice,
                ) => unknown;
            };
            union?: {
                preVisitor?: (orig: Algebra.Union) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Union>,
                    orig: Algebra.Union,
                ) => unknown;
            };
            values?: {
                preVisitor?: (orig: Algebra.Values) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.Values>,
                    orig: Algebra.Values,
                ) => unknown;
            };
            ZeroOrMorePath?: {
                preVisitor?: (
                    orig: Algebra.ZeroOrMorePath,
                ) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.ZeroOrMorePath>,
                    orig: Algebra.ZeroOrMorePath,
                ) => unknown;
            };
            ZeroOrOnePath?: {
                preVisitor?: (
                    orig: Algebra.ZeroOrOnePath,
                ) => Awaitable<TransformContext>;
                transform?: (
                    copy: SafeWrap<Safe, Algebra.ZeroOrOnePath>,
                    orig: Algebra.ZeroOrOnePath,
                ) => unknown;
            };
        },
        nodeSpecificCallBacks: {
            add?: {};
            alt?: {};
            ask?: {};
            bgp?: {};
            clear?: {};
            compositeupdate?: {};
            construct?: {};
            copy?: {};
            create?: {};
            deleteinsert?: {};
            describe?: {};
            distinct?: {};
            drop?: {};
            expression?: {
                aggregate?: {
                    preVisitor?: (
                        op:
                            | Algebra.AggregateExpression
                            | Algebra.GroupConcatExpression
                            | Algebra.BoundAggregate,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<
                            Safe,
                            | Algebra.AggregateExpression
                            | Algebra.GroupConcatExpression
                            | Algebra.BoundAggregate,
                        >,
                        orig:
                            | Algebra.AggregateExpression
                            | Algebra.GroupConcatExpression
                            | Algebra.BoundAggregate,
                    ) => unknown;
                };
                existence?: {
                    preVisitor?: (
                        op: Algebra.ExistenceExpression,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<Safe, Algebra.ExistenceExpression>,
                        orig: Algebra.ExistenceExpression,
                    ) => unknown;
                };
                named?: {
                    preVisitor?: (
                        op: Algebra.NamedExpression,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<Safe, Algebra.NamedExpression>,
                        orig: Algebra.NamedExpression,
                    ) => unknown;
                };
                operator?: {
                    preVisitor?: (
                        op: Algebra.OperatorExpression,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<Safe, Algebra.OperatorExpression>,
                        orig: Algebra.OperatorExpression,
                    ) => unknown;
                };
                term?: {
                    preVisitor?: (
                        op: Algebra.TermExpression,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<Safe, Algebra.TermExpression>,
                        orig: Algebra.TermExpression,
                    ) => unknown;
                };
                wildcard?: {
                    preVisitor?: (
                        op: Algebra.WildcardExpression,
                    ) => Awaitable<TransformContext>;
                    transform?: (
                        copy: SafeWrap<Safe, Algebra.WildcardExpression>,
                        orig: Algebra.WildcardExpression,
                    ) => unknown;
                };
            };
            extend?: {};
            filter?: {};
            from?: {};
            graph?: {};
            group?: {};
            inv?: {};
            join?: {};
            leftjoin?: {};
            link?: {};
            load?: {};
            minus?: {};
            move?: {};
            nop?: {};
            nps?: {};
            OneOrMorePath?: {};
            orderby?: {};
            path?: {};
            pattern?: {};
            project?: {};
            reduced?: {};
            seq?: {};
            service?: {};
            slice?: {};
            union?: {};
            values?: {};
            ZeroOrMorePath?: {};
            ZeroOrOnePath?: {};
        },
    ): Promise<Safe extends "unsafe" ? OutType : unknown>

  • Async variant of transformNodeSpecific, supporting promise-returning callbacks. The traversal is strictly sequential (depth-first) - it does not parallelise siblings.

    Type Parameters

    • Safe extends Safeness = "safe"
    • OutType = unknown

    Parameters

    • startObject: object
    • nodeCallBacks: {
          add?: {
              preVisitor?: (orig: Algebra.Add) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Add>,
                  orig: Algebra.Add,
              ) => unknown;
          };
          alt?: {
              preVisitor?: (orig: Algebra.Alt) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Alt>,
                  orig: Algebra.Alt,
              ) => unknown;
          };
          ask?: {
              preVisitor?: (orig: Algebra.Ask) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Ask>,
                  orig: Algebra.Ask,
              ) => unknown;
          };
          bgp?: {
              preVisitor?: (orig: Algebra.Bgp) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Bgp>,
                  orig: Algebra.Bgp,
              ) => unknown;
          };
          clear?: {
              preVisitor?: (orig: Algebra.Clear) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Clear>,
                  orig: Algebra.Clear,
              ) => unknown;
          };
          compositeupdate?: {
              preVisitor?: (
                  orig: Algebra.CompositeUpdate,
              ) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.CompositeUpdate>,
                  orig: Algebra.CompositeUpdate,
              ) => unknown;
          };
          construct?: {
              preVisitor?: (orig: Algebra.Construct) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Construct>,
                  orig: Algebra.Construct,
              ) => unknown;
          };
          copy?: {
              preVisitor?: (orig: Algebra.Copy) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Copy>,
                  orig: Algebra.Copy,
              ) => unknown;
          };
          create?: {
              preVisitor?: (orig: Algebra.Create) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Create>,
                  orig: Algebra.Create,
              ) => unknown;
          };
          deleteinsert?: {
              preVisitor?: (
                  orig: Algebra.DeleteInsert,
              ) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.DeleteInsert>,
                  orig: Algebra.DeleteInsert,
              ) => unknown;
          };
          describe?: {
              preVisitor?: (orig: Algebra.Describe) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Describe>,
                  orig: Algebra.Describe,
              ) => unknown;
          };
          distinct?: {
              preVisitor?: (orig: Algebra.Distinct) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Distinct>,
                  orig: Algebra.Distinct,
              ) => unknown;
          };
          drop?: {
              preVisitor?: (orig: Algebra.Drop) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Drop>,
                  orig: Algebra.Drop,
              ) => unknown;
          };
          expression?: {
              preVisitor?: (orig: Algebra.Expression) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Expression>,
                  orig: Algebra.Expression,
              ) => unknown;
          };
          extend?: {
              preVisitor?: (orig: Algebra.Extend) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Extend>,
                  orig: Algebra.Extend,
              ) => unknown;
          };
          filter?: {
              preVisitor?: (orig: Algebra.Filter) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Filter>,
                  orig: Algebra.Filter,
              ) => unknown;
          };
          from?: {
              preVisitor?: (orig: Algebra.From) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.From>,
                  orig: Algebra.From,
              ) => unknown;
          };
          graph?: {
              preVisitor?: (orig: Algebra.Graph) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Graph>,
                  orig: Algebra.Graph,
              ) => unknown;
          };
          group?: {
              preVisitor?: (orig: Algebra.Group) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Group>,
                  orig: Algebra.Group,
              ) => unknown;
          };
          inv?: {
              preVisitor?: (orig: Algebra.Inv) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Inv>,
                  orig: Algebra.Inv,
              ) => unknown;
          };
          join?: {
              preVisitor?: (orig: Algebra.Join) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Join>,
                  orig: Algebra.Join,
              ) => unknown;
          };
          leftjoin?: {
              preVisitor?: (orig: Algebra.LeftJoin) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.LeftJoin>,
                  orig: Algebra.LeftJoin,
              ) => unknown;
          };
          link?: {
              preVisitor?: (orig: Algebra.Link) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Link>,
                  orig: Algebra.Link,
              ) => unknown;
          };
          load?: {
              preVisitor?: (orig: Algebra.Load) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Load>,
                  orig: Algebra.Load,
              ) => unknown;
          };
          minus?: {
              preVisitor?: (orig: Algebra.Minus) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Minus>,
                  orig: Algebra.Minus,
              ) => unknown;
          };
          move?: {
              preVisitor?: (orig: Algebra.Move) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Move>,
                  orig: Algebra.Move,
              ) => unknown;
          };
          nop?: {
              preVisitor?: (orig: Algebra.Nop) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Nop>,
                  orig: Algebra.Nop,
              ) => unknown;
          };
          nps?: {
              preVisitor?: (orig: Algebra.Nps) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Nps>,
                  orig: Algebra.Nps,
              ) => unknown;
          };
          OneOrMorePath?: {
              preVisitor?: (
                  orig: Algebra.OneOrMorePath,
              ) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.OneOrMorePath>,
                  orig: Algebra.OneOrMorePath,
              ) => unknown;
          };
          orderby?: {
              preVisitor?: (orig: Algebra.OrderBy) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.OrderBy>,
                  orig: Algebra.OrderBy,
              ) => unknown;
          };
          path?: {
              preVisitor?: (orig: Algebra.Path) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Path>,
                  orig: Algebra.Path,
              ) => unknown;
          };
          pattern?: {
              preVisitor?: (orig: Algebra.Pattern) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Pattern>,
                  orig: Algebra.Pattern,
              ) => unknown;
          };
          project?: {
              preVisitor?: (orig: Algebra.Project) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Project>,
                  orig: Algebra.Project,
              ) => unknown;
          };
          reduced?: {
              preVisitor?: (orig: Algebra.Reduced) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Reduced>,
                  orig: Algebra.Reduced,
              ) => unknown;
          };
          seq?: {
              preVisitor?: (orig: Algebra.Seq) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Seq>,
                  orig: Algebra.Seq,
              ) => unknown;
          };
          service?: {
              preVisitor?: (orig: Algebra.Service) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Service>,
                  orig: Algebra.Service,
              ) => unknown;
          };
          slice?: {
              preVisitor?: (orig: Algebra.Slice) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Slice>,
                  orig: Algebra.Slice,
              ) => unknown;
          };
          union?: {
              preVisitor?: (orig: Algebra.Union) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Union>,
                  orig: Algebra.Union,
              ) => unknown;
          };
          values?: {
              preVisitor?: (orig: Algebra.Values) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.Values>,
                  orig: Algebra.Values,
              ) => unknown;
          };
          ZeroOrMorePath?: {
              preVisitor?: (
                  orig: Algebra.ZeroOrMorePath,
              ) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.ZeroOrMorePath>,
                  orig: Algebra.ZeroOrMorePath,
              ) => unknown;
          };
          ZeroOrOnePath?: {
              preVisitor?: (
                  orig: Algebra.ZeroOrOnePath,
              ) => Awaitable<TransformContext>;
              transform?: (
                  copy: SafeWrap<Safe, Algebra.ZeroOrOnePath>,
                  orig: Algebra.ZeroOrOnePath,
              ) => unknown;
          };
      }
    • nodeSpecificCallBacks: {
          add?: {};
          alt?: {};
          ask?: {};
          bgp?: {};
          clear?: {};
          compositeupdate?: {};
          construct?: {};
          copy?: {};
          create?: {};
          deleteinsert?: {};
          describe?: {};
          distinct?: {};
          drop?: {};
          expression?: {
              aggregate?: {
                  preVisitor?: (
                      op:
                          | Algebra.AggregateExpression
                          | Algebra.GroupConcatExpression
                          | Algebra.BoundAggregate,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<
                          Safe,
                          | Algebra.AggregateExpression
                          | Algebra.GroupConcatExpression
                          | Algebra.BoundAggregate,
                      >,
                      orig:
                          | Algebra.AggregateExpression
                          | Algebra.GroupConcatExpression
                          | Algebra.BoundAggregate,
                  ) => unknown;
              };
              existence?: {
                  preVisitor?: (
                      op: Algebra.ExistenceExpression,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<Safe, Algebra.ExistenceExpression>,
                      orig: Algebra.ExistenceExpression,
                  ) => unknown;
              };
              named?: {
                  preVisitor?: (
                      op: Algebra.NamedExpression,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<Safe, Algebra.NamedExpression>,
                      orig: Algebra.NamedExpression,
                  ) => unknown;
              };
              operator?: {
                  preVisitor?: (
                      op: Algebra.OperatorExpression,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<Safe, Algebra.OperatorExpression>,
                      orig: Algebra.OperatorExpression,
                  ) => unknown;
              };
              term?: {
                  preVisitor?: (
                      op: Algebra.TermExpression,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<Safe, Algebra.TermExpression>,
                      orig: Algebra.TermExpression,
                  ) => unknown;
              };
              wildcard?: {
                  preVisitor?: (
                      op: Algebra.WildcardExpression,
                  ) => Awaitable<TransformContext>;
                  transform?: (
                      copy: SafeWrap<Safe, Algebra.WildcardExpression>,
                      orig: Algebra.WildcardExpression,
                  ) => unknown;
              };
          };
          extend?: {};
          filter?: {};
          from?: {};
          graph?: {};
          group?: {};
          inv?: {};
          join?: {};
          leftjoin?: {};
          link?: {};
          load?: {};
          minus?: {};
          move?: {};
          nop?: {};
          nps?: {};
          OneOrMorePath?: {};
          orderby?: {};
          path?: {};
          pattern?: {};
          project?: {};
          reduced?: {};
          seq?: {};
          service?: {};
          slice?: {};
          union?: {};
          values?: {};
          ZeroOrMorePath?: {};
          ZeroOrOnePath?: {};
      }

    Returns Promise<Safe extends "unsafe" ? OutType : unknown>