Variable mapOperationSubPreOrderAsyncConst

Type Declaration

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