CommonStepsHelper

abstract def _traversal: Traversal[ST[Start], ET[End], Steps]

implicit abstract def target: Graph

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def and(traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList], traversals: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList]*): Traversal[ST[Start], ET[End], ::[And, Steps]]

def as[S <: String](name: () ⇒ S): Traversal[ST[Start], ET[End], ::[As[End, S], Steps]]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def coalesce[ET0 <: ClassType[_], End1, ET1 <: ClassType[End1], Steps1 <: HList, Steps2 <: HList, Labels1 <: HList, Labels2 <: HList](traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, Steps1], traversals: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, Steps2]*)(implicit f1: Aux[Steps1, LabelSteps.type, Labels1], f2: Aux[Steps2, LabelSteps.type, Labels2], ev2: =:=[Labels1, Labels2], et0: Aux[ET0, End1, ET1]): Traversal[ST[Start], ET1, ::[Coalesce[ET[End], ET0], Steps]]

def dedup(): Traversal[ST[Start], ET[End], ::[Dedup, Steps]]

def drop(): Traversal[ST[Start], ET[End], ::[Drop, Steps]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def et: ET[End]

def finalize(): Unit

final def getClass(): Class[_]

def group[AZ <: ClassType[_]](by: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], AZ, _ <: HList]): Traversal[ST[Start], ET[End], ::[Group[AZ], Steps]]

def hashCode(): Int

def is(predicate: P[End], predicates: P[_]*): Traversal[ST[Start], ET[End], ::[Is, Steps]]

final def isInstanceOf[T0]: Boolean

def local[ET0 <: ClassType[_], Labels1 <: HList](traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, _ <: HList]): Traversal[ST[Start], ET0, ::[Local, Steps]]

final def ne(arg0: AnyRef): Boolean

def not(traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList]): Traversal[ST[Start], ET[End], ::[Not, Steps]]

final def notify(): Unit

final def notifyAll(): Unit

def or(traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList], traversals: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList]*): Traversal[ST[Start], ET[End], ::[Or, Steps]]

def path[ET0 <: ClassType[_], End1, ET1 <: ClassType[End1], Steps0 <: HList](traversal: (Traversal[ET[End], ClassType[Any], HNil]) ⇒ Traversal[ET[End], ET0, Steps0])(implicit et0: Aux[ET0, End1, ET1]): Traversal[ST[Start], ET1, ::[Path, Steps]]

def path: Traversal[ST[Start], ClassType[Any], ::[Path, Steps]]

TODO: result of path is a List[ET0]

def project[A, AZ[+Z] <: ClassType[Z], B, BZ[+Z] <: ClassType[Z], C, CZ[+Z] <: ClassType[Z], D, DZ[+Z] <: ClassType[Z], ABCDZ <: ClassType[_]](by1: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], AZ[A], _ <: HList], by2: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], BZ[B], _ <: HList], by3: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], CZ[C], _ <: HList], by4: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], DZ[D], _ <: HList])(implicit listHelper: Aux[::[AZ[A], ::[BZ[B], ::[CZ[C], ::[DZ[D], HNil]]]], List, ABCDZ]): Traversal[ST[Start], Tuple4Type[A, B, C, D], ::[Project, Steps]]

def project[A, AZ[+Z] <: ClassType[Z], B, BZ[+Z] <: ClassType[Z], C, CZ[+Z] <: ClassType[Z], ABCZ <: ClassType[_]](by1: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], AZ[A], _ <: HList], by2: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], BZ[B], _ <: HList], by3: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], CZ[C], _ <: HList])(implicit listHelper: Aux[::[AZ[A], ::[BZ[B], ::[CZ[C], HNil]]], List, ABCZ]): Traversal[ST[Start], Tuple3Type[A, B, C], ::[Project, Steps]]

def project[A, AZ[+Z] <: ClassType[Z], B, BZ[+Z] <: ClassType[Z], ABZ <: ClassType[_]](by1: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], AZ[A], _ <: HList], by2: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], BZ[B], _ <: HList])(implicit listHelper: Aux[::[AZ[A], ::[BZ[B], HNil]], List, ABZ]): Traversal[ST[Start], Tuple2Type[A, B], ::[Project, Steps]]

def repeat[ET0 <: ClassType[_]](traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, _ <: HList], until: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList] = null, max: Int = 0, collect: Boolean = false): Traversal[ST[Start], ET0, ::[Repeat[ET0], Steps]]

def st: ST[Start]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def union[ET0 <: ClassType[_], End1, ET1 <: ClassType[End1], Steps1 <: HList, Steps2 <: HList, Labels1 <: HList, Labels2 <: HList](traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, Steps1], traversals: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], ET0, Steps2]*)(implicit f1: Aux[Steps1, LabelSteps.type, Labels1], f2: Aux[Steps2, LabelSteps.type, Labels2], ev2: =:=[Labels1, Labels2], et0: Aux[ET0, End1, ET1]): Traversal[ST[Start], ET1, ::[Union[ET[End], ET0], Steps]]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def where(traversal: (Traversal[ET[End], ET[End], HNil]) ⇒ Traversal[ET[End], _ <: ClassType[_], _ <: HList]): Traversal[ST[Start], ET[End], ::[Where, Steps]]